# GraphOps RPC

Source: https://docs.graphops.xyz/rpc

Read balances and contract state, submit signed transactions, and react to new blocks without
running your own nodes. GraphOps RPC works with familiar EVM libraries over HTTPS and WebSocket,
and supports Bitcoin RPC over HTTPS.

## RPC at a glance

_Your app sends JSON-RPC requests over HTTPS or WebSocket. GraphOps nodes follow the chain and answer each one._

- Your app: JSON-RPC
- RPC: Nodes
- Chain: New blocks
- [Run the RPC quickstart](/rpc/getting-started)
- [Open the RPC reference](/rpc/methods)

## Choose RPC when

Use RPC when your application needs direct node calls or already uses an EVM library such as
`viem`, go-ethereum's `ethclient`, `alloy`, or `web3.py`. You control how calls are combined and how
results are stored.

For an indexed GraphQL data model, choose [Subgraphs](/subgraphs). For an ordered stream feeding
your own database, choose [Substreams](/substreams).

## What you can build

Each pattern uses standard EVM JSON-RPC methods and works with any EVM client library.
Your application decides how requests combine and where results are stored.

- [Consistent reads at one block](/rpc/guides/read-contract-state): Price a pool or value a position from several eth_call reads pinned to the same block.

- [Event history in bounded ranges](/rpc/guides/backfill-historical-events): Build a transfer history with eth_getLogs, one resumable block range at a time.

- [Transaction submission and receipts](/rpc/guides/send-raw-transaction): Broadcast a transaction you signed, store its hash, and poll for the receipt.

- [Live events over WebSocket](/rpc/guides/websocket-subscriptions): React to new heads and matching logs, and backfill any gap after a reconnect.

Bitcoin applications can call Bitcoin Core-compatible methods over HTTPS; see
[Bitcoin endpoints](/rpc/api#bitcoin-endpoints).

## What you run and what GraphOps runs

*GraphOps runs the nodes behind authenticated endpoints and meters usage. Your application signs transactions, chooses block references, retries, and stores anything it builds from responses.*

Your application:
- Signing keys and nonces
- Block references for related reads
- Retries, batching, and backoff
- Storage built from responses

Endpoint: `rpc.graphops.xyz/v1/evm/<CHAIN_ID>` (API key in a header or the path).

GraphOps operates:
- EVM and Bitcoin nodes
- HTTPS for EVM and Bitcoin, WebSocket for EVM
- API keys, metering, and credits

## Supported networks

Use the live network catalog to choose an EVM or Bitcoin endpoint and check archive coverage.

[Choose your network and copy its endpoint](/rpc/networks).

## Integration paths

EVM RPC supports both HTTPS and WebSocket transports. Bitcoin RPC currently supports HTTPS.

| Transport | Use it for                                                                           |
| --------- | ------------------------------------------------------------------------------------ |
| HTTPS     | Single requests, batch requests, reads, transaction submission, and polling filters. |
| WebSocket | Subscriptions such as new heads, logs, pending transactions, and syncing updates.    |

Authenticate requests with an organization-scoped API key. Use header authentication for clients
that can attach headers, or route-token authentication for WebSocket clients and HTTPS clients that
cannot attach custom headers. See [Authentication](/rpc/authentication).

## Production behavior

Separate `latest` reads can observe different chain states. If a workflow compares several values,
select a block first and reuse its number or hash for every call. Choose a finalized block when
you need stable results more than the newest data.

Calls and subscription events consume credits at their current rates. Plan for shared request and
concurrency limits across your organization.

## Next steps

* [Make your first RPC request](/rpc/getting-started): Create an API key and read the latest Ethereum block.
* [Consistency and finality](/rpc/concepts/consistency-and-finality): Choose a block reference before combining several reads.
* [Usage and limits](/rpc/usage-and-limits): Estimate credits and plan for shared rate and concurrency limits.