Introducing Support For The IPFS RPC API

You No Longer Need to Run an IPFS Node

If you’ve ever deployed a Kubo IPFS node just to integrate with the HTTP API — this is for you. Filebase now supports a hosted IPFS RPC API, letting you interact with IPFS using native RPC routes like /api/v0/add, /api/v0/cat, and /api/v0/pin/add — all without running any node infrastructure yourself.

It’s the same interface exposed by a local Kubo node. But now it’s hosted, secured, authenticated, and production-ready — served by Filebase at:

https://rpc.filebase.io

🧠 What This Actually Means

Until now, if your team wanted to build with IPFS without relying on public gateways, you had to spin up a node (or a cluster of nodes), manage networking, configure storage, expose ports, and handle RPC auth.

That’s no longer required.

With Filebase’s RPC endpoint:

• You get hosted access to the Kubo-compatible IPFS API
• You can run standard IPFS commands like add, cat, and pin
• You get pinned, persistent storage — backed by Filebase infrastructure
• And you can plug in existing IPFS libraries and CLI tools with zero changes

There’s no gateway redirect. No abstraction layer. This is raw IPFS — just hosted for you.

🛠 How It Works

The RPC API follows the same conventions as the Kubo IPFS node’s HTTP API. Every route is available under the base URL:

https://rpc.filebase.io

All requests must be authenticated using your Filebase API key:

Authorization: Bearer <your-api-key>

Keys are available from your Access Keys page.

💡 Why Use This Instead of Running Your Own Node?

If you're an enterprise team, a startup, or just a solo dev — running an IPFS node has costs:

• Nodes consume bandwidth and compute
• You need to manage pinning, storage persistence, and garbage collection
• You need TLS termination, RPC authorization, and rate limiting
• And if you go multi-node, you’re suddenly managing a distributed cluster

With the Filebase RPC API:

• You skip all of that
• You still get native IPFS compatibility
• You gain persisted, content-addressed storage, pinned automatically
• And your infra becomes as simple as calling an HTTP API

This gives you the flexibility of IPFS without the ops overhead.

📡 Supported Endpoints

Here’s what’s supported at launch — and why it matters.

POST /api/v0/add

Upload a file (or files) to IPFS.

• Input: multipart/form-data file fields
• Optional:
  • wrap-with-directory=true — returns a directory CID
  • cid-version=0 — returns CIDv0 (default)
  • cid-version=1 — returns CIDv1

📌 Use it to: stream uploads from apps, CLI tools, or CI jobs.

POST /api/v0/cat

Fetch the raw contents of a file by CID.

• Input: arg=cid query param

📌 Use it to: retrieve JSON, images, metadata, and more by CID.

POST /api/v0/block/get

Fetch a raw block from IPFS.

• Input: arg=cid query param

📌 Use it to: load low-level DAG nodes or use IPFS as a blockstore.

POST /api/v0/pin/add

Pin a CID to make sure it's persisted.

• Input: arg=cid query param

📌 Use it to: persist content you’ve referenced or discovered elsewhere.

POST /api/v0/pin/rm

Unpin a CID.

• Input: arg=cid query param

📌 Use it to: remove data from persistence (it may still exist temporarily).

POST /api/v0/pin/ls

List all currently pinned objects.

📌 Use it to: audit what’s stored or manage lifecycle logic.

POST /api/v0/version

Returns the version of the IPFS daemon (for compatibility checking).

📌 Use it to: verify compatibility with existing tooling.

🧪 Real Examples

Add a File to IPFS via curl

curl -X POST "https://rpc.filebase.io/api/v0/add" \
  -H "Authorization: Bearer <api-key>" \
  -F "file=@myfile.png"

Add a Folder to IPFS via curl

curl -X POST "https://rpc.filebase.io/api/v0/add?wrap-with-directory=true" \
  -H "Authorization: Bearer <api-key>" \
  -F "file=@myfile1.png" -F "file=@myfile2.png" -F "file=@myfile3.png"

Using fetch() in Node.js

const fs = require('fs');
const fetch = require('node-fetch');
const FormData = require('form-data');

const form = new FormData();
form.append('file', fs.createReadStream('./myfile.jpeg'));

fetch('https://rpc.filebase.io/api/v0/add', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer <api-key>',
  },
  body: form,
})
  .then(res => res.json())
  .then(console.log)
  .catch(console.error);

Use the IPFS CLI with Filebase

ipfs --api="/dns4/rpc.filebase.io/tcp/443/https" \
  --api-auth="<api-key>" \
  add myfile.jpg

Yes, that’s the official IPFS CLI — no fork or patch required. Supported when using Kubo v0.33 or later.

🔐 Fully Authenticated + HTTPS

Every request is served over TLS and requires an API key. That key controls access to your Filebase namespace, so there’s no risk of public abuse.

This makes it safe to integrate into production apps, backend services, or internal workflows.

🧩 RPC vs S3: Use Both

Filebase also offers an S3-compatible API, which is great for multi-part uploads, bucketed storage, and direct integration with AWS tools.

Use RPC when:

• You want native IPFS compatibility
• You're calling from IPFS-native tools
• You want CID-first storage logic

Use S3 when:

• You need structured buckets or multi-part uploads
• You're integrating with AWS SDKs or Terraform
• You’re accessing storage by object key, not CID

Both point to the same underlying content-addressable system — and both are production-ready.

🧭 Docs + Dev Resources

• 📘 Full RPC API docs
• 🔐 Get your API key

Go Node-Free

If you’ve been running IPFS nodes just to build with CIDs, there’s a better way now.

Let Filebase handle the infra. You just build.

Start here:

https://rpc.filebase.io

—

Questions? Feedback? Want support for more RPC routes?

💬 Join our Discord
🐦 Follow @Filebase on X