Blockchain API

JSON-RPC to 40+ chains, plus DEX routing and DeFi protocol data, through a single URL. No node to run, no per-chain provider key.

JSON-RPC access to 29 EVM and 11 non-EVM blockchains, best-execution swap routing across 100+ decentralised exchanges, and TVL, yield and price data for 3000+ DeFi protocols.

Coverage

29 EVM networks (Ethereum, Base, Arbitrum One and Nova, Optimism, Polygon, BNB, Avalanche, Fantom and more) and 11 non-EVM (Solana, Bitcoin, Litecoin, Dogecoin, NEAR, Sui, XRP, Polkadot and others), alongside swap routing across 100+ exchanges and TVL, yield and price data for 3000+ DeFi protocols.

RPC reads hit the chain directly, with hot-read caching for cheap constants such as chain id and block number. Swap quotes are live; a firm quote returns signable transaction data.

10 endpoints

Multi-chain RPC

Standard JSON-RPC 2.0. The chain is a path segment; the method is whatever that chain supports. Batch arrays are accepted and charged per element.

DEX routing

Best-execution quotes across 100+ exchanges via Permit2. Quote, sign one EIP-712 message, broadcast.

DeFi protocol data

TVL, yields and token prices across 3000+ protocols on every major chain.

Pricing

RPC is a flat rate per call, the same on every chain. Swap quotes are billed per call and gas stays yours to pay on-chain. Batch RPC arrays are charged per element, so a 10-call batch costs ten reads.

Quick start

cURL

# EVM read — the chain is the path segment
curl -X POST "https://api.jarvisclaw.ai/v1/marketplace/rpc/base" \
  -H "Authorization: Bearer sk-your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'

# Solana uses its own method names, same URL shape
curl -X POST "https://api.jarvisclaw.ai/v1/marketplace/rpc/solana" \
  -H "Authorization: Bearer sk-your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getSlot"}'

# Indicative swap quote
curl "https://api.jarvisclaw.ai/v1/marketplace/dex/price?chainId=8453&sellToken=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913&buyToken=0x4200000000000000000000000000000000000006&sellAmount=1000000" \
  -H "Authorization: Bearer sk-your-api-key"

# DeFi protocol TVL
curl "https://api.jarvisclaw.ai/v1/marketplace/defi/protocols" \
  -H "Authorization: Bearer sk-your-api-key"

Python

import requests

BASE = "https://api.jarvisclaw.ai/v1/marketplace"
headers = {"Authorization": "Bearer sk-your-api-key"}

def rpc(chain, method, params=None):
    return requests.post(
        f"{BASE}/rpc/{chain}",
        headers=headers,
        json={"jsonrpc": "2.0", "id": 1, "method": method, "params": params or []},
    ).json()

# Same call shape, different chains
print(rpc("ethereum", "eth_blockNumber")["result"])
print(rpc("base", "eth_gasPrice")["result"])
print(rpc("solana", "getSlot")["result"])

# A batch is one request but N charges — one per element
batch = requests.post(
    f"{BASE}/rpc/base",
    headers=headers,
    json=[
        {"jsonrpc": "2.0", "id": 1, "method": "eth_blockNumber"},
        {"jsonrpc": "2.0", "id": 2, "method": "eth_gasPrice"},
    ],
).json()

# Yields across protocols — a large response, stream it
yields = requests.get(f"{BASE}/defi/yields", headers=headers, stream=True)

JavaScript

const BASE = 'https://api.jarvisclaw.ai/v1/marketplace'
const headers = {
  Authorization: 'Bearer sk-your-api-key',
  'Content-Type': 'application/json',
}

const rpc = (chain, method, params = []) =>
  fetch(`${BASE}/rpc/${chain}`, {
    method: 'POST',
    headers,
    body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
  }).then((r) => r.json())

const block = await rpc('base', 'eth_blockNumber')
const slot = await rpc('solana', 'getSlot')

// Firm swap quote carries the transaction to sign
const quote = await fetch(
  `${BASE}/dex/quote?chainId=8453&sellToken=${USDC}&buyToken=${WETH}&sellAmount=1000000`,
  { headers },
).then((r) => r.json())

Use cases

• Multi-chain apps without multi-chain plumbing — One base URL and one key covers 40+ networks; adding a chain is changing a path segment.
• Agents that read chain state — An agent with a funded wallet can query balances, blocks and logs without ever holding a provider key.
• Swap execution — Quote across 100+ exchanges, sign one message, broadcast — or go gasless and let the relayer pay.
• Yield and TVL research — Rank 3000+ protocols by TVL or APY and track how those figures move.
• Indexers and monitors — Poll blocks and receipts on several chains from one place, with hot reads cached.
• Portfolio tracking — Balances from RPC, positions from DeFi data, prices from swap quotes.

FAQ

Which chains are supported?

29 EVM networks and 11 non-EVM, including Ethereum, Base, Arbitrum, Optimism, Polygon, BNB, Avalanche, Solana, Bitcoin, NEAR, Sui, XRP and Polkadot. The chain is the last path segment.

Do I need a separate key per chain?

No. One JarvisClaw key — or one funded agent wallet — covers every chain and every method.

How are batch JSON-RPC requests billed?

Per element. A batch array of ten calls is one HTTP request and ten charges, which matches what the upstream provider bills us.

Is gas included in the swap price?

No. The API charge covers the quote; on-chain gas is paid by whoever broadcasts. The gasless endpoints are the exception — there the relayer absorbs gas.

Can I use this as a drop-in RPC URL in my wallet or library?

Yes for POST JSON-RPC, which is what ethers, viem and web3.py send. WebSocket subscriptions are not part of this surface.

What happens if I call a chain that is not supported?

The request is refused rather than forwarded and charged. Read the 402 quote first if you want to confirm a route before paying.

Documentation

• Marketplace endpoints overview — RPC, DEX and DeFi base paths in the service directory
• DEX Trading reference — Permit2 and gasless swap flows end to end
• Solana payments — Settling in USDC on Solana rather than Base
• Quick Start — First call in under five minutes