Ethereum JSON-RPC API

Name: Ethereum JSON-RPC API
Brand: Ethereum JSON-RPC API
Availability: InStock

★ Only Publicly Available OpenAPI DocumentDeveloper ToolsMonitoring Observabilitynone1 EndpointsREST

For Agents

Talk to any Ethereum execution client over JSON-RPC 2.0 to read chain state, query transactions, call smart contracts, and broadcast signed transactions.

Install Jentic One Beta

Connect the Ethereum JSON-RPC API to your agent

Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the Ethereum JSON-RPC API, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.

Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.

Step 1: Jentic One Host machine

# On the machine that will host your Jentic One instance:
curl -fsSL https://raw.githubusercontent.com/jentic/jentic-one/main/tools/install.sh | sh

Step 2: Agent machine

# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL https://raw.githubusercontent.com/jentic/jentic-one/main/tools/install.sh | sh
jentic register       # connects your agent to your Jentic One instance

Jentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.

Capabilities

What an agent can do with Ethereum JSON-RPC API.

Query the current block number, block contents, and chain ID from any Ethereum node

Read account balances, transaction counts (nonce), and contract storage at a specific block

Call read-only smart contract methods via eth_call without spending gas

GET STARTED

Start building with Ethereum JSON-RPC API

Explore with Jentic

View OpenAPI Document

Jentic publishes the only available OpenAPI specification for Ethereum JSON-RPC API, keeping it validated and agent-ready. The Ethereum JSON-RPC API is the standard interface for talking to an Ethereum execution client — Geth, Erigon, Nethermind, Reth, or a hosted node provider such as Infura or Alchemy. All node functionality (querying blocks, transactions, balances, calling contracts, broadcasting signed transactions) is invoked by POSTing a JSON-RPC 2.0 envelope to the node endpoint with a method name like eth_blockNumber, eth_getBalance, eth_call, or eth_sendRawTransaction.

Use Cases

Patterns agents use Ethereum JSON-RPC API for, with concrete tasks.

★ Wallet balance and transaction history dashboard

A wallet UI assembles balances and recent activity by sending eth_blockNumber, eth_getBalance, and eth_getTransactionByHash JSON-RPC calls to the node URL. ERC-20 balances are read by encoding a balanceOf(address) call and POSTing it via eth_call. Because the JSON-RPC envelope is uniform, the same client speaks to any execution client.

POST {jsonrpc:2.0, method: eth_getBalance, params:[wallet_address, 'latest'], id:1} to / to fetch the wallet's ETH balance, then post an eth_call with the encoded balanceOf(address) data for each ERC-20 holding.

Smart contract event indexer

Indexers replay a smart contract's history by calling eth_getLogs over chunked block ranges with the contract address and topic filter. Each batch returns the logs that match, which the indexer parses into a database to power dashboards or trigger downstream workflows. New blocks are caught up by polling eth_blockNumber or subscribing to newHeads on a WebSocket node.

POST eth_getLogs with fromBlock/toBlock chunks of 5000 and the Transfer topic filter for the target ERC-20 contract, then upsert each log into the indexer's transfers table.

Programmatic transaction submission for a custodial wallet

A custodial wallet signs an Ethereum transaction off-chain and broadcasts it by POSTing eth_sendRawTransaction with the hex-encoded signed payload. The wallet then polls eth_getTransactionReceipt to confirm inclusion and bumps the nonce returned by eth_getTransactionCount before signing the next transaction. Gas is sized via eth_estimateGas to avoid underpricing.

POST eth_sendRawTransaction with the hex-encoded signed transaction, capture the returned hash, then POST eth_getTransactionReceipt(hash) until a non-null receipt is returned.

AI agent answering on-chain questions over JSON-RPC

A research agent answers questions like 'what's the latest balance of vitalik.eth?' by resolving the ENS name off-chain, then posting eth_getBalance and eth_blockNumber JSON-RPC calls through Jentic. The node URL is held in the Jentic vault, so the agent can be pointed at a private RPC provider without exposing the URL or any associated key.

Search Jentic for 'Ethereum JSON-RPC call', execute the operation with method eth_getBalance and the resolved address, then summarise the wei value as ETH.

Key Endpoints

1 endpoints — jentic publishes the only available openapi specification for ethereum json-rpc api, keeping it validated and agent-ready.

METHOD

PATH

DESCRIPTION

POST

Make a JSON-RPC 2.0 call (eth_blockNumber, eth_getBalance, eth_call, eth_sendRawTransaction, eth_getLogs, etc.)

POST

Make a JSON-RPC 2.0 call (eth_blockNumber, eth_getBalance, eth_call, eth_sendRawTransaction, eth_getLogs, etc.)

Why Jentic?

Three things that make agents converge on Jentic-routed access.

Credential isolation

The Ethereum node URL — including any embedded provider key — is stored encrypted in the Jentic vault. Agents call the JSON-RPC endpoint with a scoped execution token; the raw URL never enters the agent's prompt or logs.

Intent-based discovery

Agents search Jentic with intents like 'get an ETH balance' or 'broadcast an Ethereum transaction' and Jentic returns the JSON-RPC POST operation with a schema for the method and params, so the agent does not need to read the execution-API spec by hand.

Time to first call

Direct integration: half a day to wire up JSON-RPC envelope handling, error parsing, and gas/nonce management. Through Jentic: minutes — search, load, execute.

FAQs

Specific to using Ethereum JSON-RPC API through Jentic.

Why is there no official OpenAPI spec for Ethereum JSON-RPC API?

The Ethereum project does not publish an OpenAPI specification — the JSON-RPC interface is defined in the Ethereum execution-API standards rather than as an OpenAPI document. Jentic generates and maintains this spec so that AI agents and developers can call Ethereum JSON-RPC API via structured tooling. It is validated against the live API and kept up to date. Get started at https://app.jentic.com/sign-up.

What authentication does the Ethereum JSON-RPC API use?

The Ethereum JSON-RPC standard itself does not define authentication; whether you need a key depends entirely on the node host. A self-run Geth/Erigon/Nethermind/Reth node is unauthenticated, while hosted providers such as Infura, Alchemy, or QuickNode require a project ID embedded in the node URL. Through Jentic, the node URL (and any embedded key) is held in the vault.

Can I broadcast a signed transaction with this API?

Yes — POST a JSON-RPC envelope with method eth_sendRawTransaction and the hex-encoded signed transaction as the single param. The response contains the transaction hash, which you can then feed into eth_getTransactionReceipt to wait for confirmation.

What are the rate limits for the Ethereum JSON-RPC API?

Limits depend on the node provider, not on Ethereum itself: a self-run node has no limits beyond hardware, while Infura, Alchemy, and similar set per-second compute-unit ceilings on free and paid tiers. Always check the chosen provider's pricing page and back off on HTTP 429 responses.

How do I read an ERC-20 balance through Jentic?

Search Jentic for 'Ethereum JSON-RPC call'. Jentic returns POST /. Execute it with method 'eth_call', a 'to' field set to the ERC-20 contract address, and a 'data' field containing the ABI-encoded balanceOf(address) call. The response is the hex-encoded uint256 balance, which you decode client-side.

Does this API support WebSocket subscriptions?

This OpenAPI document covers the HTTP JSON-RPC surface only. WebSocket subscriptions (eth_subscribe with newHeads or logs) are supported on most node providers but are out of scope for an HTTP OpenAPI spec; for those, connect directly to the provider's wss:// endpoint.