Pinata IPFS enables secure storage, upload, and retrieval of files on decentralized networks with Pinata's IPFS API inte
by pinatacloud·Read, analyze, and understand files in your project
Example: Summarize README, analyze code structure, find TODO comments across codebase
Navigate large codebases 5x faster, understand projects quickly
Create, move, rename, and organize files based on natural language instructions
Example: Organize downloads by file type, rename files following convention, batch process images
Save hours on manual file organization
Search files for patterns, extract data, find information across directories
Example: Find all config files with API keys, extract emails from documents, search logs for errors
Find information instantly instead of manual grep/find
Generate boilerplate files, apply templates, create project structures
Example: Create React component with tests and styles, generate OpenAPI spec, scaffold new project
Eliminate repetitive file creation work
Tigris Storage
Tigris Storage offers S3-compatible object storage, manage aws s3 buckets, storage blobs, and binary large object storag
Akave Storage
Akave Storage: Manage buckets, upload/download files, and generate signed URLs with automatic text cleaning on Akave's S
Fast Filesystem
Fast Filesystem offers memory-efficient file operations, compress to zip or rar format, with backup and editing. Try wit
Put.io
Control put.io file transfers remotely with AI, supporting easy management and browser-based downloads via secure authen
@zhigang1992/uploadfile-mcp
Upload local files to S3-compatible storage and get shareable public S3 URLs. Auto-organized into UUID folders to avoid
Useful MCP listing: Pinata IPFS is the kind of server we cite when onboarding engineers to host + tool permissions.
Pinata IPFS has been reliable for tool-calling workflows; the MCP profile page is a good permalink for internal docs.
Pinata IPFS is among the better-indexed MCP projects we tried; the explainx.ai summary tracks the official description.
Pinata IPFS reduced integration guesswork — categories and install configs on the listing matched the upstream repo.
Pinata IPFS reduced integration guesswork — categories and install configs on the listing matched the upstream repo.
According to our notes, Pinata IPFS benefits from clear Model Context Protocol framing — fewer ambiguous “AI plugin” claims.
Useful MCP listing: Pinata IPFS is the kind of server we cite when onboarding engineers to host + tool permissions.
We evaluated Pinata IPFS against two servers with overlapping tools; this profile had the clearer scope statement.
I recommend Pinata IPFS for teams standardizing on MCP; the explainx.ai page compares cleanly with sibling servers.
We wired Pinata IPFS into a staging workspace; the listing’s GitHub and npm pointers saved time versus hunting across READMEs.
showing 1-10 of 33
Share your MCP server with the developer community
Select a client to integrate this server.
Claude Desktop configuration
{
"mcpServers": {
"pinata": {
"command": "npx",
"args": [
"pinata-mcp"
],
"env": {
"PINATA_JWT": "\u003CYOUR_JWT\u003E",
"GATEWAY_URL": "example.mypinata.cloud"
}
}
}
}Connects to Pinata's IPFS storage services to upload, manage, and retrieve files on decentralized networks. Supports both public and private IPFS networks with secure API authentication.
Pinata IPFS is an official MCP server published by pinatacloud that provides AI assistants with tools and capabilities via the Model Context Protocol. Pinata IPFS enables secure storage, upload, and retrieval of files on decentralized networks with Pinata's IPFS API inte It is categorized under file systems.
You can install Pinata IPFS in your AI client of choice. Use the install panel on this page to get one-click setup for Cursor, Claude Desktop, VS Code, and other MCP-compatible clients. This server runs locally on your machine via the stdio transport.
A Model Context Protocol (MCP) server that provides Claude with access to Pinata. This integration allows Claude to interact with Public and Private IPFS through Pinata's API.
Installation will depend on whether you are using Claude Code or Claude Desktop.
Claude Code
Run claude mcp add and follow the prompts with the following information:
Server Name: pinata
Server Scope: Project or Global
Server Command: npx
Command Arguments: pinata-mcp /path/to/allowed/directory
Environment Variables: PINATA_JWT=<YOUR_JWT>,GATEWAY_URL=example.mypinata.cloud
Claude Desktop
Add the following config to claude_desktop_config.json:
{
"mcpServers": {
"pinata": {
"command": "npx",
"args": [
"pinata-mcp",
"/path/to/allowed/directory",
"/another/allowed/directory"
],
"env": {
"PINATA_JWT": "<YOUR_JWT>",
"GATEWAY_URL": "example.mypinata.cloud"
}
}
}
}
Note: The directory arguments are optional. If not provided, the server will only allow access to the current working directory. You can specify multiple directories to allow file access from multiple locations.
| Tool | Description |
|---|---|
testAuthentication | Verify that your Pinata JWT is valid and working |
| Tool | Description |
|---|---|
uploadFile | Upload a file to Pinata (public or private IPFS) |
searchFiles | Search files by name, CID, or MIME type |
getFileById | Get detailed file information by ID |
updateFile | Update file metadata (name, key-values) |
deleteFile | Delete a file from Pinata |
| Tool | Description |
|---|---|
createLink | Create a gateway link for public or private files |
createPrivateDownloadLink | Generate a temporary download link for private files |
fetchFromGateway | Fetch content from IPFS via Pinata gateway |
| Tool | Description |
|---|---|
listGroups | List groups with optional filtering |
createGroup | Create a new group for organizing files |
getGroup | Get group details by ID |
updateGroup | Update group information |
deleteGroup | Delete a group |
addFileToGroup | Add a file to a group |
removeFileFromGroup | Remove a file from a group |
Tools for content monetization using the x402 protocol:
| Tool | Description |
|---|---|
createPaymentInstruction | Create payment requirements for gated content |
listPaymentInstructions | List/filter existing payment instructions |
getPaymentInstruction | Get details of a specific payment instruction |
updatePaymentInstruction | Modify payment instruction settings |
deletePaymentInstruction | Remove a payment instruction |
listPaymentInstructionCids | List CIDs associated with a payment instruction |
addCidToPaymentInstruction | Associate a CID with a payment instruction |
removeCidFromPaymentInstruction | Remove a CID association |
Tools for cryptographic content verification using EIP-712 signatures:
| Tool | Description |
|---|---|
addSignature | Add a cryptographic signature to a CID |
getSignature | Get signature details by CID |
deleteSignature | Remove a signature |
| Tool | Description |
|---|---|
createSignedUploadUrl | Create a presigned URL for client-side uploads |
| Tool | Description |
|---|---|
pinByCid | Pin an existing CID from the IPFS network |
queryPinRequests | Query the status of pin requests |
cancelPinRequest | Cancel a pending pin request |
| Tool | Description |
|---|---|
vectorizeFile | Vectorize a file for semantic search |
deleteFileVectors | Delete vectors for a file |
queryVectors | Query vectorized files using semantic search |
| Tool | Description |
|---|---|
listAllowedDirectories | List directories the server can access for file operations |
To test the MCP server locally during development:
git clone https://github.com/PinataCloud/pinata-mcp.git
cd pinata-mcp
npm install
npm run build
Create a .env file in the project root (optional, you can also pass these in the MCP config):
PINATA_JWT=your_pinata_jwt_here
GATEWAY_URL=your-gateway.mypinata.cloud
Claude Code
Run claude mcp add with the local path:
Server Name: pinata-dev
Server Scope: Project
Server Command: node
Command Arguments: /path/to/pinata-mcp/dist/index.js /path/to/allowed/directory
Environment Variables: PINATA_JWT=<YOUR_JWT>,GATEWAY_URL=example.mypinata.cloud
Claude Desktop
Update claude_desktop_config.json to point to your local build:
{
"mcpServers": {
"pinata-dev": {
"command": "node",
"args": [
"/path/to/pinata-mcp/dist/index.js",
"/path/to/allowed/directory"
],
"env": {
"PINATA_JWT": "<YOUR_JWT>",
"GATEWAY_URL": "example.mypinata.cloud"
}
}
}
}
After making code changes:
npm run buildUse the MCP Inspector to test the server:
Web UI (interactive debugging)
npx @modelcontextprotocol/inspector \
-e PINATA_JWT=your_jwt \
-e GATEWAY_URL=your-gateway.mypinata.cloud \
-- node dist/index.js
This opens a browser UI where you can interactively list tools, call them with parameters, and inspect responses.
CLI mode (for scripting/CI)
# List all available tools
npx @modelcontextprotocol/inspector --cli --method tools/list \
-e PINATA_JWT=your_jwt \
-e GATEWAY_URL=your-gateway.mypinata.cloud \
-- node dist/index.js
# Call a specific tool
npx @modelcontextprotocol/inspector --cli --method tools/call \
--tool-name testAuthentication \
-e PINATA_JWT=your_jwt \
-e GATEWAY_URL=your-gateway.mypinata.cloud \
-- node dist/index.js
Test my Pinata connection:
"Test my Pinata authentication to make sure everything is working"
Upload an image to Pinata:
"Upload this image to my Pinata account as a private file named 'My Example Image'"
Search for files:
"Search my Pinata account for all PNG files"
Create a group and add files:
"Create a new group called 'Project Assets' on Pinata, then find all my JSON files and add them to this group"
Fetch content from IPFS:
"Fetch the content with CID QmX... from IPFS"
Create a payment instruction for content monetization:
"Create a payment instruction called 'Premium Content' that requires 0.01 USDC on Base to access"
Pin an existing CID:
"Pin the CID bafkreih5aznjvttude6c3wbvqeebb6rlx5wkbzyppv7garjiubll2ceym4 to my account"
Vectorize files for AI search:
"Vectorize the file with ID abc123 so I can search it semantically"
Query vectorized content:
"Search my vectorized files in group xyz for 'machine learning concepts'"
Time estimate: 10-20 minutes including configuration
Prerequisites
Steps
Troubleshooting
✓ Do
✗ Don't
💡 Pro Tips
Architecture
MCP server provides file I/O operations (read, write, search, metadata) as tools Claude can invoke with natural language instructions.
Protocols
Compatibility
✓ Use when
Use for code analysis, file organization, content search, template generation, and automating repetitive file operations. Best for local development workflows.
✗ Avoid when
Avoid for system-critical files, sensitive credentials, production environments, or when file integrity is paramount. Don't use on files you can't afford to lose.