Request excerpt. See the service quickstart for authentication and a complete example.
JSON-RPC parameters
// WebSocket: follow each new Ethereum head.{"method":"eth_subscribe","params":["newHeads"]}// HTTPS: one batch per head, every read pinned to its hash.[{"method":"eth_getBlockTransactionCountByHash","params":["<head hash>"]}, {"method":"eth_call","params":[ {"to":"0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640","data":"0x3850c7bd"}, {"blockHash":"<head hash>","requireCanonical":true}]}]// The batch adds liquidity() and each token's balanceOf(pool).// slot0() gives sqrtPriceX96. The collector computes USDC per WETH.
USDC / WETH pool state
What is RPC?
RPC is how applications talk to a blockchain node: you send a JSON-RPC request, and the node reads chain state or submits a signed transaction. GraphOps RPC serves EVM networks over HTTPS and WebSocket, and Bitcoin over HTTPS. Your application combines requests, handles retries, and passes explicit block references when related reads must be consistent.
Each pattern uses documented EVM JSON-RPC methods and works with any EVM client library. Your application decides how requests combine and where results are stored.
Price a pool, value a portfolio, or check a position from several reads that must describe the same chain state. Separate latest reads can land on different blocks, so resolve one block and pass its number or hash to every call.
Select a block with eth_blockNumber, safe, or finalized, and store its number or hash.
Pass that reference to each eth_call, eth_getBalance, or eth_getStorageAt request.
Combine the results knowing they describe one block.
You own
Choosing the block reference and carrying it through the workflow.
Plan for
A recent block can still be reorganized. Use safe or finalized when stability matters more than freshness.
All three reads name block N, so price, liquidity, and balance describe one chain state.
02eth_getLogs · fromBlock · toBlock
Event history in bounded ranges
Build a transfer history, audit trail, or analytics table from contract events. Request logs one bounded range at a time, filtered by contract address and event topic, and record each completed range so a failed job resumes where it stopped.
Filter eth_getLogs by contract address and event topic.
Start with a narrow range and widen it only after observing response size and latency.
Write logs idempotently by (blockHash, transactionHash, logIndex), then store the last completed block.
You own
Range sizing, progress storage, and deduplication.
Plan for
Older ranges need archive access on the network you choose, and broad ranges can hit response-size or timeout limits.
Send payments, swaps, or contract calls signed in your wallet or signer service. GraphOps RPC broadcasts the signed payload and does not custody private keys. Store the transaction hash before reporting success, then poll for the receipt and apply your own confirmation policy.
Check eth_chainId and plan fees with eth_estimateGas and eth_feeHistory before signing.
Broadcast with eth_sendRawTransaction and store the returned hash.
Poll eth_getTransactionReceipt until it returns a receipt, then wait for the finality your workflow needs.
You own
Transaction signing, nonce and fee policy, and confirmation rules.
Plan for
Retrying the same signed transaction is usually safe because its hash is deterministic. Do not change gas, nonce, or value and resend blindly.
The hash comes back at submission. The receipt shows inclusion in block N, and your policy decides when that block is final enough.
04eth_subscribe · newHeads · logs
Live events over WebSocket subscriptions
Update balances, send notifications, or start jobs as new heads and matching logs arrive through WebSocket subscriptions. Connections can drop, so record the last block you processed and backfill any gap with eth_getLogs after you resubscribe. Treat logs marked removed: true as reversals.
Subscribe to newHeads or filtered logs with eth_subscribe.
Store the last processed block and log identity.
After a disconnect, reconnect with backoff, resubscribe, and backfill missed blocks with eth_getLogs.
You own
Reconnects, gap backfills, and deduplication.
Plan for
A new subscription delivers new events only. Blocks missed while disconnected need your backfill.
Request rate, batch size, and WebSocket connection and subscription limits apply to your whole organization, across all of its API keys. Support can raise them.
Log scans, state proofs, and trace and debug methods cost more credits per call than standard reads. Log scans and trace and debug methods are also charged by response size, so split broad log scans into ranges and trace one transaction when you need only part of a block.
RPC requests are rate-limited per organization. A request over the limit gets 429 with request_rate_limited and a Retry-After header, and is not billed. Retry after it, with backoff and jitter.
Go from a new organization to a first response, then prepare for production traffic.
01
Create an organization and add credits
Choose your monthly credits or buy a top-up. RPC calls and subscription events consume credits at the current rates.
02
Create an API key that includes RPC
Send it in an Authorization header, or in the endpoint path for WebSocket and HTTPS clients that cannot set headers.
03
Choose a network endpoint
The EVM path ends in the chain ID, and Bitcoin endpoints use a network name. Copy the exact endpoint from the network catalog.
04
Read the latest block
Run eth_blockNumber with curl or your EVM library to confirm the key and endpoint.
05
Prepare for production
Keep your organization under its request rate limit, retry a 429 after its Retry-After, pin related reads to one block, and split broad log scans into ranges.
Endpoints
EVM over HTTPSReads, batches, and transaction submission
https://rpc.graphops.xyz/v1/evm/<chainId>
EVM over WebSocketSubscriptions to new heads and logs
wss://rpc.graphops.xyz/v1/evm/<chainId>
Bitcoin over HTTPSBitcoin Core-compatible RPC
https://rpc.graphops.xyz/v1/bitcoin/<network>
EVM supports HTTPS and WebSocket. Bitcoin supports HTTPS. Check the network documentation for endpoints, archive and tracing access.