MinIO Go Client SDK: Go Library for S3 Storage

What is the MinIO Go Client SDK?

MinIO Go Client SDK is a Go library that gives programs straightforward APIs for working with any Amazon S3 compatible object storage service, per its own README. It's distributed as github.com/minio/minio-go/v7 and installed with `go get`, and it wraps everything — buckets, objects, presigned URLs, bucket policies and notifications — behind a minio.Client you initialize once with an endpoint and credentials.

Installing the MinIO Go Client

Installation is a single command: `go get github.com/minio/minio-go/v7`, run from your project directory — the README assumes you already have a working Go development environment set up. There's no separate config file or credentials bootstrap step documented for the SDK itself; you build a `minio.Client` in code by passing an endpoint and a `minio.Options` struct with credentials (the README shows `credentials.NewStaticV4` for a static access key and secret) and a `Secure` flag for TLS. The full API reference lives at pkg.go.dev (godoc) and at MinIO's own Go Client API Reference page, not inline in the repo.

Uploading Files with Go

The README's canonical example connects to `play.min.io` — MinIO's public test cluster, which the README warns should be treated as public and non-protected for anything uploaded there — using a hardcoded static access key and secret. From there it's four calls: build the client with `minio.New`, call `MakeBucket` (falling back to a `BucketExists` check if the bucket already exists, since re-running the example a second time would otherwise error), then `FPutObject` to push a local file straight from disk with a `ContentType` set, which returns an `info.Size` you can log to confirm the upload. The counterpart for downloads, `FGetObject`, pulls a remote object straight to a local file path the same way. Verification in the example happens outside Go entirely, via `mc ls play/testbucket` on the command line.

Key Capabilities for Object Storage

• ✓Bucket operations covering the full lifecycle — MakeBucket, ListBuckets, BucketExists, RemoveBucket, ListObjects, and ListIncompleteUploads.
• ✓Object operations for everyday transfer and management: GetObject, PutObject, PutObjectStreaming, StatObject, CopyObject, RemoveObject, and a batch RemoveObjects call.
• ✓File-based helpers, FPutObject and FGetObject, that move a local file straight to or from a bucket without you handling io.Reader plumbing yourself.
• ✓Presigned URL generation — PresignedGetObject, PresignedPutObject, PresignedHeadObject, and PresignedPostPolicy — for handing out time-limited access without exposing credentials.
• ✓Bucket policy and notification management (SetBucketPolicy, SetBucketNotification, and related calls), plus examples covering bucket lifecycle, encryption, and replication settings.
• ✓Two operations the README flags explicitly as MinIO Extensions rather than standard S3: ListenBucketNotification and ListenNotification, for streaming bucket events.
• ✓SelectObjectContent for running queries against object content server-side, alongside object-annotation calls (PutObjectAnnotation, GetObjectAnnotation, ListObjectAnnotations, RemoveObjectAnnotation).
• ✓Request tracing via TraceOn/TraceOff and app identification via SetAppInfo, both listed under the SDK's client custom-settings API.

Alternatives to MinIO Go Client

Common Questions

The problem it solves

Talking to S3-compatible storage from Go usually means either pulling in AWS's own SDK — built around AWS's broader service catalog, not just S3 — or hand-implementing the AWS Signature V4 signing scheme yourself. MinIO Go Client SDK's own topics list `aws-signature` and `client-sdk` alongside `s3`, and its README frames the whole project around one narrow job: give Go code straightforward APIs against any S3-compatible object storage endpoint, MinIO or otherwise, without either of those two costs.

Best use cases

• •Uploading and downloading files from a Go backend to MinIO or another S3-compatible store, using FPutObject/FGetObject instead of wiring up io.Reader/io.Writer plumbing by hand.
• •Generating time-limited, credential-free download or upload links for end users via PresignedGetObject and PresignedPutObject.
• •Managing bucket lifecycle, encryption, and replication settings from Go code, since the repository ships full runnable examples for each.
• •Streaming bucket-level events (object created, removed, and similar) from a MinIO server specifically, via the MinIO Extension calls ListenBucketNotification and ListenNotification.
• •Running server-side queries against object content with SelectObjectContent instead of downloading a whole object just to filter it client-side.

Who should try it — and who should skip

Try MinIO Go Client SDK if you're writing a Go service that needs to read or write objects in MinIO or any other S3-compatible store and want a client built specifically around the S3 API rather than a general-purpose cloud SDK — the bucket/object/presigned surface covers the operations most apps actually need. Skip it if your Go code already depends on AWS SDK for Go for other AWS services beyond S3, where switching just the storage calls to a second SDK adds a dependency without removing the first one; skip it too if you need the MinIO Extension calls (ListenBucketNotification, ListenNotification) to run unmodified against a non-MinIO S3 backend, since the README marks those as MinIO-specific.

Related repositories