# How to Set Up HTTPS Localhost for MinIO on macOS

> Generate locally-trusted SSL certificates with mkcert and run MinIO in Docker over HTTPS on your Mac. Updated for 2026, when the official minio/minio image stopped pulling.

Canonical: https://www.bucketmate.app/blogs/minio-https-localhost-macos

Running MinIO over HTTPS locally mirrors production security, satisfies browser requirements for modern web APIs, and lets you test S3 SDK calls that enforce TLS. This guide walks through generating trusted certificates with `mkcert` and configuring MinIO in Docker on macOS to serve objects over a secure connection.

> **The official MinIO Docker image no longer exists.** `docker pull minio/minio` and `docker pull quay.io/minio/minio` now fail with "pull access denied" or "not found". This guide uses `cgr.dev/chainguard/minio` instead. See [Which MinIO Docker image to use in 2026](#which-minio-docker-image-to-use-in-2026) for other options.


## Which MinIO Docker image to use in 2026

MinIO stopped publishing community Docker images in October 2025, and the [minio/minio](https://github.com/minio/minio) repository was archived in April 2026. The `minio/minio` image on Docker Hub and the `quay.io/minio/minio` mirror are both gone, so older tutorials and Compose files that use them will fail to pull.

These images still pull as of October 2026:

| Image | What it is | Notes |
| --- | --- | --- |
| `cgr.dev/chainguard/minio` | [Chainguard MinIO image](https://images.chainguard.dev/directory/image/minio/overview), built from MinIO source | Free `latest` tag, minimal and regularly rebuilt. Runs as a non-root user, so pass `--certs-dir /certs` for TLS. Used in this guide. |
| `pgsty/minio` | [Community fork](https://github.com/pgsty/minio) maintained by Pigsty | Drop-in replacement for `minio/minio`. Same entrypoint and `/root/.minio/certs` path, so old commands work by swapping the image name. |
| `quay.io/minio/aistor/minio` | MinIO AIStor, the supported commercial product | Has a free edition. Follow the [AIStor docs](https://docs.min.io/aistor/) for licensing and setup. |

If you only need a local S3 endpoint for testing, either of the first two works. Pin a digest or version tag in scripts so an upstream change does not break your setup. More background in [MinIO status in 2026](/blogs/minio-macos-s3-bucket-setup#minio-status-in-2026).

Using `pgsty/minio` with the commands from older versions of this guide:

```shell
docker run --rm \
  -p 9000:9000 -p 9001:9001 \
  -v $HOME/minio-data:/data \
  -v $HOME/.minio/certs:/root/.minio/certs \
  pgsty/minio server /data --console-address ":9001"
```


## TL;DR


```shell
# Command to setup HTTPS for MinIO on macOS
brew install mkcert nss
mkcert -install
mkcert localhost 127.0.0.1 ::1

mkdir -p ~/.minio/certs
cp localhost+2.pem ~/.minio/certs/public.crt
cp localhost+2-key.pem ~/.minio/certs/private.key

mkdir -p ~/minio-data

docker run --rm \
  -p 9000:9000 -p 9001:9001 \
  -v $HOME/minio-data:/data \
  -v $HOME/.minio/certs:/certs \
  cgr.dev/chainguard/minio server /data --certs-dir /certs --console-address ":9001"

# Config to connect to MinIO with BucketMate
- Provider: MinIO
- Endpoint: https://localhost:9000
- Access key: minioadmin
- Secret key: minioadmin
- Region: 'us-east-1'
```


## Why enable HTTPS for local MinIO

- Modern web APIs: Service Workers, WebCrypto, and Secure Contexts require HTTPS - even on localhost when testing from a custom domain or LAN IP.
- SDK parity: The AWS SDK and tools like rclone can enforce TLS verification. Matching production behavior locally catches configuration bugs early.
- Mobile and cross-device testing: Devices connecting over your LAN need valid certificates to avoid security warnings and connection failures.
- BucketMate requirement: BucketMate only supports HTTPS connections - HTTP endpoints will not work. Setting up TLS on your local MinIO is required to use it with BucketMate.

## 1. Create trusted localhost certificates


Install `mkcert` and the `nss` package for Firefox trust store integration:


```shell
brew install mkcert nss
```


Create and install the local Certificate Authority into the macOS Keychain and browser trust stores:


```shell
mkcert -install
```


Generate certificates for localhost:


```shell
mkcert localhost 127.0.0.1 ::1
```


You will get two files in your current directory:

- `localhost+2.pem` - the certificate
- `localhost+2-key.pem` - the private key

## 2. Create certs folder for MinIO


MinIO expects the certificate and key as `public.crt` and `private.key` in its certs directory. Create a folder for them and copy the files with the required names:


```shell
mkdir -p ~/.minio/certs
cp localhost+2.pem ~/.minio/certs/public.crt
cp localhost+2-key.pem ~/.minio/certs/private.key
```


## 3. Create data directory for MinIO


Create a persistent location for object data:


```shell
mkdir -p ~/minio-data
```


## 4. Start MinIO container with certs mounted


Run MinIO in Docker with the certificates directory mounted at `/certs` and passed to `--certs-dir`. The Chainguard image runs as a non-root user, so the explicit flag replaces the old `/root/.minio/certs` path:


```shell
docker run --rm \
  -p 9000:9000 -p 9001:9001 \
  -v $HOME/minio-data:/data \
  -v $HOME/.minio/certs:/certs \
  cgr.dev/chainguard/minio server /data --certs-dir /certs --console-address ":9001"
```


Check the startup output for confirmation that TLS is enabled:


```plain text
API: https://0.0.0.0:9000
WebUI: https://0.0.0.0:9001
```


## 5. Access MinIO

- S3 API: https://localhost:9000
- Console: https://localhost:9001

Open the console URL in a browser. You should see a green padlock - no certificate warnings. The default credentials are `minioadmin` for both username and password.


## 6. Connect BucketMate to HTTPS MinIO

1. Click Add connection → Provider: Others.
2. Enter the endpoint `https://localhost:9000`.
3. Input your access key and secret key (default is `minioadmin` / `minioadmin`).
4. Tap Test connection - BucketMate validates the certificate against the system trust store.
5. Click Add connection to add the connection to your sidebar.

BucketMate uses AWS SDK, so it needs an HTTPS connection.


![image.png](/blogs/minio-https-localhost-macos/image.png)


## Why BucketMate for S3 management


[BucketMate](https://bucketmate.app/?utm_source=blog&utm_medium=guide&utm_campaign=minio-https) is a native macOS client for S3-compatible storage. It provides a native interface to browse, upload, and manage objects across multiple providers - including your local MinIO server.


Key features:

- Multi-provider support: Connect to AWS S3, Cloudflare R2, Backblaze B2, DigitalOcean Spaces, Wasabi, MinIO, and any S3-compatible endpoint from a single app.
- Drag-and-drop uploads: Move files between your Mac and buckets without CLI commands.
- Instant previews: View images, videos, PDFs, and text files directly in the app.
- Secure connections: BucketMate enforces HTTPS for all connections, ensuring your data is encrypted in transit.

## Next steps


You now have a production-like HTTPS setup for MinIO on macOS using Docker. Explore syncing your secure local bucket to cloud storage with the [MinIO sync guide](/blogs/minio-macos-s3-bucket-setup) or compare provider pricing in the [R2 vs S3 breakdown](/blogs/cloudflare-r2-vs-aws-s3).
