We have been quietly building a brand new API from the ground up. Our previous API(s) have largely been unchanged since Pinata’s founding. Aside from adding new endpoints and features, we did not fundamentally change the design, performance, or ergonomics of the API.

Until now.

The V3 API

Let’s start with what’s changed.

✅ Built on serverless technology to allow near-infinite scale

✅ Increased rate limits for API operations

✅ Support for resumable uploads via the tus protocol

✅ True RESTful patterns

✅ Presigned upload urls

✅ Unified interface for public and private IPFS

There’s so much more, but those points alone should be reason to celebrate. The performance gains and support for massive files via resumable uploads is a big enough update that could use an announcement of their own.

Why V3?

For years, we’ve squeezed as much performance out of our legacy API as we could, keeping up with developer demands but never outpacing those demands. We knew we wanted to build a solution that could handle any scale from our customers, and that drove the design and implementation of our V3 API.

Our rate limits for our legacy API trailed behind industry standards, and this meant many of our customers had to build custom logic to avoid hitting those limits. It also meant that uploading a lot of files took longer than we wanted it to take. With our V3 API, we have solved these constraints, and we can’t wait for developers to take advantage of this to improve their own code bases.

What This Means for Developers

With the release of our V3 API, developers finally have the tools to scale their applications without hitting painful bottlenecks. Whether you're uploading thousands of files a day or integrating IPFS support into a web app that serves millions of users, V3 is built to meet you there. Here's how.

Uploading Files: Faster, Smarter, Resumable

Uploading a file is now as simple as a single POST request to /files, supporting the Web API standard for File objects. This means browser compatibility is seamless, and local file handling with Node.js works by creating File objects from Blobs.

const formData = new FormData();
formData.append("file", file);
formData.append("network", "public");

await fetch("<https://uploads.pinata.cloud/v3/files>", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.PINATA_JWT}`,
  },
  body: formData,
});

Want to upload large files with resumable support? Use our tus implementation—no more restarting from zero when a connection drops. Simply connect a tus client to https://uploads.pinata.cloud/v3/tus.

A Unified File Interface

Files are now managed with consistent methods whether they’re on the public or private IPFS networks. Need to list, update, or delete files? You use the same intuitive pattern across both scopes:

• GET /files/public
• PUT /files/private/{id}
• DELETE /files/public/{id}

Files can be grouped, signed, swapped, and even vectorized (for AI search use cases). Everything you need is accessible through consistent REST endpoints or via our fully typed SDK.

Generate Signed Upload URLs

Need to allow a user to upload a file without exposing your JWT? Create presigned URLs with:

await pinata.upload.public.createSignedURL({
  expires: 300,
  name: "myUpload.png",
});

Users can upload directly with the signed URL, and you can set custom metadata, groups, or expiration logic. Possibly more important is that you can limit the uploads to specific file types or specific sizes.

A Better Developer Experience

You deserve an API that is simple to use and impossible to outgrow. With strong typing, well-documented error responses, and features like:

• Rate limits that make sense (and scale as you grow)
• Presigned links for client-side uploads
• Private file access links with expiration and optional image optimization
• Hot swaps that enable CID aliasing
• AI-powered vectorization and search in private file spaces

The V3 API represents a massive leap forward in what Pinata offers to developers.

What About The Legacy API?

Our legacy API is still supported and we currently have no plans to deprecate it. You are welcome to continue using it and our documentation allows you to switch between the legacy API and the V3 API easily.

Ready to Build?

You can start integrating right now:

• Grab your JWT from your developer dashboard
• Install the SDK: npm install pinata
• Test your authentication: pinata.testAuthentication()
• Upload a file: pinata.upload.public.file(File)

Need more advanced workflows? Add custom metadata, update file names, manage public/private access, or retrieve presigned download links—all with clear, versioned API patterns and robust SDK support.

Happy pinning!

→ Check out the V3 API docs