quickS3
Server Details
Give your AI agent access to S3-compatible storage without handing it your access keys. quickS3 is a hosted MCP server: the agent signs in through your browser, borrows only the roles you pick, and moves files through short-lived links.
⠀ ⠀
🔐 Why use it
⠀ ⠀
No keys on the machine. OAuth sign-in in your browser. Your storage credentials stay encrypted in quickS3.
Scoped by roles. Delegate read-only access to one folder, or write access to one bucket. Deny rules always win.
Files never pass through the chat. Downloads and uploads use short-lived signed links, and bytes go straight to your provider.
No delete, no silent overwrite. There is no delete, copy, move, or rename tool.
Audited and revocable. Every agent action is logged. Revoke a grant in one click, and grants expire after 30, 60, or 90 days.
⠀ ⠀
🧰 Tools
⠀ ⠀
Tool | What it does | Needs |
| Lists the storage connections the grant can use | Read or write |
| Lists the buckets on one connection | Read or write |
| Lists one folder level, filtered by your roles | Read |
| Single-use download link, valid 5 minutes | Read |
| Public link for someone without an account, 5 minutes to 30 days⠀ | Read |
| Presigned upload URL, valid 15 minutes, no overwrite by default | Write |
⠀ ⠀
☁️ Providers
⠀ ⠀
AWS S3, Cloudflare R2, Backblaze B2, DigitalOcean Spaces, Wasabi, MinIO, Azure Blob Storage, and other S3-compatible services.
⠀ ⠀
🚀 Get started
⠀ ⠀
Create a quickS3 organization at quicks3.com and add a storage connection.
Add
https://quicks3.com/mcpas a remote MCP server in Claude, ChatGPT, Codex, or any client that supports Streamable HTTP with OAuth.Approve the agent and pick its roles. ⠀ ⠀ For Claude Code and Codex, the open source quickS3 plugin installs the server and the
quicks3-operatorskill.
⠀ ⠀
quickS3 is a paid service. Setup guide · Security model
- Status
- Healthy
- OAuth
- Works in Glama
- Last Tested
- Transport
- Streamable HTTP
- URL
TDQS
Scored across 6 tools
Each tool targets a distinct resource and action: two create-link variants are clearly separated by purpose (self-download vs public sharing), and the three list tools separate connections, buckets, and objects. The descriptions reinforce the boundaries, so an agent should not misselect.
All tools follow a consistent snake_case verb_noun pattern: create_* for link/URL generation and list_* for enumeration. The verbs and nouns map cleanly to the underlying operations with no style mixing or vague generic names.
With 6 tools, the set is well-scoped for a server that lists storage resources and creates access links. Each tool earns its place, and the count feels neither thin nor bloated for the stated purpose.
The core workflows—discover connections/buckets/objects and create upload, download, or share links—are covered, so agents can complete primary tasks. Minor gaps exist: there is no tool to manage or revoke links, even though the share-link description references revocation, and no way to list existing links.
Available Tools
6 toolscreate_download_linkCreate download linkARead-onlyInspect
Create a short-lived download link (valid 5 minutes, single use) for one object. Download the file by following the link, e.g. with curl -L -o output.bin "<uri>". quickS3 never sees or stores the file contents; the link redirects directly to your storage provider.
| Name | Required | Description | Default |
|---|---|---|---|
| key | Yes | Object key, e.g. "reports/2026/q3.csv" | |
| bucket | Yes | Bucket name | |
| connectionId | Yes | Connection ID from list_connections |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds value beyond the readOnlyHint annotation by explaining that the tool does not store file contents and redirects directly to the storage provider. This gives the agent a clear behavioral model without conflicting with the annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, with only two sentences that pack in essential details: validity, single-use, how to use the link, and privacy behavior. It is front-loaded with the core purpose and uses a useful example.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with 3 required parameters and no output schema, the description covers everything an agent needs: purpose, usage, and behavior. No critical missing information.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already covers all parameters with descriptions (coverage 100%), and the description doesn't add extra parameter-level detail. It provides context on how to use the link, but that's more about usage than parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: creating a short-lived download link for a single object. It specifies the resource (object) and action (create a link), and distinguishes it from siblings like create_share_link and create_upload_url by mentioning download-specific context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly explains how to use the link (with curl example) and mentions the link's lifetime and single-use nature, which implies when to use this tool (for immediate downloads). It doesn't contrast with siblings, but the context makes the use case clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
create_upload_urlCreate upload URLAInspect
Create a short-lived presigned upload URL (valid 15 minutes) for one object. Upload the file directly to your storage provider with an HTTP PUT to the returned url, sending every header in the returned headers (e.g. curl -H "x-ms-blob-type: BlockBlob" -T localfile "<url>" for Azure). Uploads fail without those headers. quickS3 never sees or stores the file contents.
| Name | Required | Description | Default |
|---|---|---|---|
| key | Yes | Object key to write, e.g. "reports/2026/q3.csv" | |
| size | Yes | File size in bytes | |
| bucket | Yes | Bucket name | |
| overwrite | No | Allow replacing an existing object (default false) | |
| contentType | No | Content type of the file, e.g. "text/csv" | |
| connectionId | Yes | Connection ID from list_connections |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only say readOnlyHint=false and destructiveHint=false, which is minimal. The description adds rich behavioral context: the URL is short-lived, valid for one object, requires specific headers, and quickS3 never sees or stores the file contents. This goes well beyond the structured annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact, front-loaded with the core purpose, and every sentence adds value. The curl example is concise and directly illustrates the required header behavior without unnecessary verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having no output schema, the description explains what the tool returns (url and headers) and how to use them. Combined with full schema coverage for parametersais, the description is complete for an agent to invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all six parameters. The description adds context around the returned url and headers but does not add new semantic detail for parameters like key, bucket, size, or contentType beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool creates a presigned upload URL for one object, with a specific verb and resource. It is distinguishable from sibling tools like create_download_link and create_share_link because it explicitly frames the action as uploading via HTTP PUT.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear practical usage instructions: upload directly to the provider, use PUT, include returned headers, and note the 15-minute validity. It does not explicitly name alternatives or exclusion cases, but the upload-vs-download context is implied by the sibling names and the direct-upload instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_bucketsList bucketsARead-onlyInspect
List the buckets of one storage connection that this access grant can see.
| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | Yes | Connection ID from list_connections |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the description adds the visibility scoping ('that this access grant can see') beyond annotations. However, it does not disclose pagination, ordering, or response format, leaving a moderate gap given the lack of an output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with zero filler. It directly states the action and scope, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only list tool with one documented parameter and no output schema, the description covers the essential purpose and scope. It lacks explicit return format details, but the read-only annotation and parameter description provide sufficient context for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% (connectionId is described as 'Connection ID from list_connections'). The tool description adds no additional parameter meaning beyond what the schema already provides, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action (List) on a specific resource (buckets) and scopes it to one storage connection visible to the access grant. This clearly distinguishes it from siblings like list_objects (objects) and list_connections (connections).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context ('of one storage connection') and the schema documents that connectionId comes from list_connections, but it does not explicitly say when to use this tool over alternatives or mention any exclusions. Usage guidance is implied rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_connectionsList storage connectionsARead-onlyInspect
List the storage connections (S3, R2, Spaces, B2, ...) this access grant can see.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the operation readOnly, and the description adds a useful scoping detail: results are limited to what the access grant can see. It does not disclose pagination or return format, but for a zero-parameter read-only tool that is a minor gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded with the action and resource, with examples and scope in a compact parenthetical. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple zero-parameter read-only tool, the description covers what the tool does and the visibility constraint. It does not describe the shape of the returned connection list, but no output schema exists and the operation is simple enough that this is a minor omission.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and an empty schema, so the description does not need to explain parameter meaning. The baseline of 4 applies because there is nothing for parameters to add.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('List') and resource ('storage connections') with concrete examples (S3, R2, Spaces, B2) and a scoping qualifier ('this access grant can see'). This makes it easy to distinguish from sibling tools like list_buckets and list_objects, which operate on different resource types.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly indicates this is the tool for enumerating storage connections within the current access grant's scope. It does not explicitly name sibling alternatives or state when not to use it, but the resource specificity gives enough context for an agent to route correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_objectsList objectsARead-onlyInspect
List objects and folders in a bucket, filtered to prefixes this access grant may read. Folders end with "/" and appear as kind "prefix".
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum objects per page (default 100) | |
| bucket | Yes | Bucket name | |
| prefix | No | Folder prefix to list, e.g. "reports/2026/". Omit for the bucket root. | |
| connectionId | Yes | Connection ID from list_connections | |
| continuationToken | No | Opaque token from a previous page |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true, and the description adds valuable behavioral context beyond that: it explains the access-grant filtering and the folder representation (folders end with '/' and appear as kind 'prefix'). This enriches the agent's understanding of scope and output without contradicting the read-only annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no wasted words. The primary purpose and access-scope constraint are front-loaded, and the folder-format note is concise and directly useful. Every sentence contributes essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple listing tool with no output schema, the description covers the key behavioral aspects: access filtering, folder representation, and implied pagination via the continuationToken parameter. It does not explicitly describe the full response shape or pagination mechanics, but these are reasonably inferable from the parameters and the read-only nature. Minor gap, but sufficient for an agent to call it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all parameters (limit, bucket, prefix, connectionId, continuationToken) already have clear descriptions. The tool description does not add additional meaning to any parameter, so it meets the baseline for a fully documented schema without going further.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'List objects and folders in a bucket' with a specific verb and resource, and adds the key scoping constraint 'filtered to prefixes this access grant may read'. This differentiates it from siblings like list_buckets and list_connections without needing to inspect schemas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context that the tool respects access-grant prefixes, implying it only shows what the caller is permitted to see. While it doesn't explicitly name alternatives, the sibling set is small and none other list objects, so the appropriate usage is evident. It lacks explicit when-not-to-use guidance but provides enough context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
6 tool updates
- First observed
create_download_link - First observed
create_share_link - First observed
create_upload_url - First observed
list_buckets - First observed
list_connections - First observed
list_objects
Publisher details
- Operator
- Gone Coding Ltd · Publisher source
- Operator website
- https://quickS3.com
- Vendor relationship
- First-party · Publisher source
- Documentation
- https://quicks3.com/s3-mcp-server/
- Trust center
- https://quicks3.com/docs/security/model/
- Restrictions
- $19/month Includes 10 users, then $2/user/month · Publisher source
Related MCP Connectors
MCP-first toolbox for agents: KV storage, auth, queue, and utility tools. Free in early access.
MCP server connecting AI agents to 100+ apps (Gmail, Slack, Notion, GitHub) via one-click OAuth.
Persistent file storage for AI agents via MCP and curl. Upload, download, and version files.
Tigris MCP Server seamlessly connects AI agents to Tigris bucket and object management.
Related MCP Servers
- AlicenseNot gradedqualityAmaintenanceEnables agents to interact with any S3-compatible storage (AWS S3, LocalStack, MinIO) via MCP, providing tools like list, read, write, delete objects and buckets.MIT
- AlicenseAqualityDmaintenanceEnables browsing S3 buckets and objects, and generating secure presigned URLs for downloads and uploads, through natural language commands in MCP clients like Claude Desktop.36 npm3MIT
- AlicenseNot gradedqualityAmaintenanceProvides MCP tools for AWS S3 and S3-compatible storage, enabling file upload, download, listing, deletion, and temporary remote file staging via natural language.BSD 3-Clause
- FlicenseAqualityDmaintenanceProvides tools for interacting with MinIO and S3-compatible object storage through MCP clients like Claude. It enables comprehensive bucket and object management, including listing, creating, uploading, and generating presigned URLs.132-
Glama MCP Gateway
Add one secure layer between your agents and this server.