eth_getProof

curl --request POST \
  --url https://tempo-mainnet.core.chainstack.com/c3ce2925b51f1ed18719fe8a23bbdccf/ \
  --header 'Content-Type: application/json' \
  --data '
{
  "jsonrpc": "2.0",
  "method": "eth_getProof",
  "params": [
    "0x20c0000000000000000000000000000000000000",
    [
      "0x0"
    ],
    "latest"
  ],
  "id": 1
}
'

import requests

url = "https://tempo-mainnet.core.chainstack.com/c3ce2925b51f1ed18719fe8a23bbdccf/"

payload = {
    "jsonrpc": "2.0",
    "method": "eth_getProof",
    "params": ["0x20c0000000000000000000000000000000000000", ["0x0"], "latest"],
    "id": 1
}
headers = {"Content-Type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'eth_getProof',
    params: ['0x20c0000000000000000000000000000000000000', ['0x0'], 'latest'],
    id: 1
  })
};

fetch('https://tempo-mainnet.core.chainstack.com/c3ce2925b51f1ed18719fe8a23bbdccf/', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://tempo-mainnet.core.chainstack.com/c3ce2925b51f1ed18719fe8a23bbdccf/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'jsonrpc' => '2.0',
    'method' => 'eth_getProof',
    'params' => [
        '0x20c0000000000000000000000000000000000000',
        [
                '0x0'
        ],
        'latest'
    ],
    'id' => 1
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://tempo-mainnet.core.chainstack.com/c3ce2925b51f1ed18719fe8a23bbdccf/"

	payload := strings.NewReader("{\n  \"jsonrpc\": \"2.0\",\n  \"method\": \"eth_getProof\",\n  \"params\": [\n    \"0x20c0000000000000000000000000000000000000\",\n    [\n      \"0x0\"\n    ],\n    \"latest\"\n  ],\n  \"id\": 1\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://tempo-mainnet.core.chainstack.com/c3ce2925b51f1ed18719fe8a23bbdccf/")
  .header("Content-Type", "application/json")
  .body("{\n  \"jsonrpc\": \"2.0\",\n  \"method\": \"eth_getProof\",\n  \"params\": [\n    \"0x20c0000000000000000000000000000000000000\",\n    [\n      \"0x0\"\n    ],\n    \"latest\"\n  ],\n  \"id\": 1\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://tempo-mainnet.core.chainstack.com/c3ce2925b51f1ed18719fe8a23bbdccf/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"jsonrpc\": \"2.0\",\n  \"method\": \"eth_getProof\",\n  \"params\": [\n    \"0x20c0000000000000000000000000000000000000\",\n    [\n      \"0x0\"\n    ],\n    \"latest\"\n  ],\n  \"id\": 1\n}"

response = http.request(request)
puts response.read_body

{
  "jsonrpc": "<string>",
  "id": 123,
  "result": {}
}

POST

eth_getProof

curl --request POST \
  --url https://tempo-mainnet.core.chainstack.com/c3ce2925b51f1ed18719fe8a23bbdccf/ \
  --header 'Content-Type: application/json' \
  --data '
{
  "jsonrpc": "2.0",
  "method": "eth_getProof",
  "params": [
    "0x20c0000000000000000000000000000000000000",
    [
      "0x0"
    ],
    "latest"
  ],
  "id": 1
}
'

import requests

url = "https://tempo-mainnet.core.chainstack.com/c3ce2925b51f1ed18719fe8a23bbdccf/"

payload = {
    "jsonrpc": "2.0",
    "method": "eth_getProof",
    "params": ["0x20c0000000000000000000000000000000000000", ["0x0"], "latest"],
    "id": 1
}
headers = {"Content-Type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'eth_getProof',
    params: ['0x20c0000000000000000000000000000000000000', ['0x0'], 'latest'],
    id: 1
  })
};

fetch('https://tempo-mainnet.core.chainstack.com/c3ce2925b51f1ed18719fe8a23bbdccf/', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://tempo-mainnet.core.chainstack.com/c3ce2925b51f1ed18719fe8a23bbdccf/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'jsonrpc' => '2.0',
    'method' => 'eth_getProof',
    'params' => [
        '0x20c0000000000000000000000000000000000000',
        [
                '0x0'
        ],
        'latest'
    ],
    'id' => 1
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://tempo-mainnet.core.chainstack.com/c3ce2925b51f1ed18719fe8a23bbdccf/"

	payload := strings.NewReader("{\n  \"jsonrpc\": \"2.0\",\n  \"method\": \"eth_getProof\",\n  \"params\": [\n    \"0x20c0000000000000000000000000000000000000\",\n    [\n      \"0x0\"\n    ],\n    \"latest\"\n  ],\n  \"id\": 1\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://tempo-mainnet.core.chainstack.com/c3ce2925b51f1ed18719fe8a23bbdccf/")
  .header("Content-Type", "application/json")
  .body("{\n  \"jsonrpc\": \"2.0\",\n  \"method\": \"eth_getProof\",\n  \"params\": [\n    \"0x20c0000000000000000000000000000000000000\",\n    [\n      \"0x0\"\n    ],\n    \"latest\"\n  ],\n  \"id\": 1\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://tempo-mainnet.core.chainstack.com/c3ce2925b51f1ed18719fe8a23bbdccf/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"jsonrpc\": \"2.0\",\n  \"method\": \"eth_getProof\",\n  \"params\": [\n    \"0x20c0000000000000000000000000000000000000\",\n    [\n      \"0x0\"\n    ],\n    \"latest\"\n  ],\n  \"id\": 1\n}"

response = http.request(request)
puts response.read_body

{
  "jsonrpc": "<string>",
  "id": 123,
  "result": {}
}

Tempo API method that returns the Merkle proof for an account and optionally some storage keys. This is useful for verifying account state without trusting the node.

Get your own node endpoint todayStart for free and get your app to production levels immediately. No credit card required.You can sign up with your GitHub, X, Google, or Microsoft account.

Parameters

address — the address to get the proof for
storageKeys — array of storage positions to prove (hex strings)
blockParameter — the block number (hex) or tag (latest, earliest, pending)

Response

result — the proof object:
- address — the account address
- accountProof — array of RLP-encoded Merkle Patricia trie nodes from state root to account
- balance — the account balance
- codeHash — the hash of the account code
- nonce — the account nonce
- storageHash — the hash of the storage trie root
- storageProof — array of storage proofs, one per requested key:
  - key — the storage key
  - value — the storage value
  - proof — array of RLP-encoded trie nodes from storage root to value

`eth_getProof` code examples

const ethers = require('ethers');
const NODE_URL = "CHAINSTACK_NODE_URL";
const provider = new ethers.JsonRpcProvider(NODE_URL);

// pathUSD token address
const PATHUSD = "0x20c0000000000000000000000000000000000000";

const getProof = async () => {
    // Get proof for storage slot 0 (often totalSupply)
    const proof = await provider.send("eth_getProof", [
      PATHUSD,
      ["0x0", "0x1"],
      "latest"
    ]);

    console.log(`Account: ${proof.address}`);
    console.log(`Balance: ${proof.balance}`);
    console.log(`Nonce: ${parseInt(proof.nonce, 16)}`);
    console.log(`Code Hash: ${proof.codeHash}`);
    console.log(`Storage Hash: ${proof.storageHash}`);

    console.log(`\nAccount Proof nodes: ${proof.accountProof.length}`);

    for (const sp of proof.storageProof) {
      console.log(`\nStorage Key: ${sp.key}`);
      console.log(`  Value: ${sp.value}`);
      console.log(`  Proof nodes: ${sp.proof.length}`);
    }
  };

getProof();

from web3 import Web3

node_url = "CHAINSTACK_NODE_URL"
web3 = Web3(Web3.HTTPProvider(node_url))

# pathUSD token address
PATHUSD = "0x20c0000000000000000000000000000000000000"

result = web3.provider.make_request("eth_getProof", [
    PATHUSD,
    ["0x0", "0x1"],
    "latest"
])

proof = result['result']
print(f"Account: {proof['address']}")
print(f"Balance: {proof['balance']}")
print(f"Nonce: {int(proof['nonce'], 16)}")
print(f"Code Hash: {proof['codeHash']}")
print(f"Storage Hash: {proof['storageHash']}")

print(f"\nAccount Proof nodes: {len(proof['accountProof'])}")

for sp in proof['storageProof']:
    print(f"\nStorage Key: {sp['key']}")
    print(f"  Value: {sp['value']}")
    print(f"  Proof nodes: {len(sp['proof'])}")

curl -X POST "CHAINSTACK_NODE_URL" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getProof",
    "params": [
      "0x20c0000000000000000000000000000000000000",
      ["0x0", "0x1"],
      "latest"
    ],
    "id": 1
  }'

Body

application/json

jsonrpc

string

default:2.0

method

string

default:eth_getProof

params

any[]

Address, storage keys array, and block parameter

integer

default:1

Response

200 - application/json

Account and storage proof

jsonrpc

string

integer

result

object

Proof object with account proof and storage proofs

Last modified on June 22, 2026

eth_getStorageAt | Tempo eth_getLogs | Tempo

APIs introduction

Node APIs

Faucet API

Chainstack platform API

eth_getProof | Tempo

Parameters

Response

`eth_getProof` code examples

Body

Response

​Parameters

​Response

​eth_getProof code examples

Body

Response

Parameters

Response

`eth_getProof` code examples