Read Ethereum Mainnet state, submit signed transactions and subscribe to node events through GraphOps RPC over HTTPS and WebSocket. Query indexed Ethereum Mainnet data through GraphQL Subgraphs, including your own Managed Subgraphs. Backfill and stream Ethereum Mainnet blocks into your own storage with Substreams.
One API key from your organization can include every service you use, and all of them draw from the organization's credit balance.
Send JSON-RPC requests over HTTPS, or open a WebSocket for subscriptions. Archive data is available: historical state, such as eth_call at a past block, and historical event logs. Execution traces are available, such as the internal calls of a transaction or a block.
https://rpc.graphops.xyz/v1/evm/1 wss://rpc.graphops.xyz/v1/evm/1
Query any Subgraph that The Graph Network serves on Ethereum Mainnet by Deployment CID or Graph Network Subgraph ID. Managed indexing runs on Ethereum Mainnet: publish a Managed Subgraph and GraphOps indexes it. Managed Subgraphs need a monthly plan.
mainnet GraphOps Subgraphs Subgraph network reference(opens in a new tab)
Backfill Ethereum Mainnet history and continue with a live gRPC stream of package output. Your
consumer commits the data and saves its cursor. Packages for Ethereum Mainnet declare
mainnet as their network.
https://1.evm.substreams.graphops.xyz GraphOps Substreams Substreams network reference(opens in a new tab)
Use these identifiers to name Ethereum Mainnet in requests, manifests and package configuration.
1 eip155:1 mainnet etheth-mainnetethereumevm-1 This request reads the latest Ethereum Mainnet block number with eth_blockNumber.
Create an API key that includes RPC in your organization and export it as GRAPHOPS_API_KEY.
The example sends it in the Authorization header.
RPC quickstart(opens in a new tab) Authentication(opens in a new tab)
Prerequisites
Set GRAPHOPS_API_KEY to your GraphOps API key.
Run the command in a terminal with curl installed.
CLI · curl
curl --fail-with-body --silent --show-error 'https://rpc.graphops.xyz/v1/evm/1' \
-H "Authorization: Bearer ${GRAPHOPS_API_KEY}" \
-H 'Content-Type: application/json' \
--data '{
"jsonrpc": "2.0",
"id": 1,
"method": "eth_blockNumber",
"params": []
}'
import { createPublicClient, http } from "viem";
const client = createPublicClient({
transport: http("https://rpc.graphops.xyz/v1/evm/1", {
retryCount: 0,
fetchOptions: {
headers: { Authorization: `Bearer ${process.env.GRAPHOPS_API_KEY}` },
},
}),
});
const result = await client.request({ method: "eth_blockNumber" });
console.log(JSON.stringify(result));
import json
import os
from web3 import Web3
w3 = Web3(
Web3.HTTPProvider(
"https://rpc.graphops.xyz/v1/evm/1",
request_kwargs={
"headers": {
"Authorization": f"Bearer {os.environ['GRAPHOPS_API_KEY']}",
},
"timeout": 30,
},
)
)
method = "eth_blockNumber"
params = []
response = w3.provider.make_request(method, params)
if "error" in response:
raise RuntimeError(response["error"])
print(json.dumps(response["result"]))
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
"github.com/ethereum/go-ethereum/rpc"
)
func main() {
ctx := context.Background()
var options []rpc.ClientOption
for name, value := range map[string]string{
"Authorization": "Bearer " + os.Getenv("GRAPHOPS_API_KEY"),
} {
options = append(options, rpc.WithHeader(name, value))
}
client, err := rpc.DialOptions(ctx, "https://rpc.graphops.xyz/v1/evm/1", options...)
if err != nil {
log.Fatal(err)
}
defer client.Close()
var params []any
if err := json.Unmarshal([]byte(`[]`), ¶ms); err != nil {
log.Fatal(err)
}
var result json.RawMessage
if err := client.CallContext(ctx, &result, "eth_blockNumber", params...); err != nil {
log.Fatal(err)
}
fmt.Println(string(result))
}
use alloy::providers::{Provider, ProviderBuilder};
use alloy::rpc::client::RpcClient;
use alloy::transports::http::Http;
use reqwest::header::{HeaderMap, HeaderName};
use serde_json::{json, Value};
use std::{env, error::Error};
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
let mut headers = HeaderMap::new();
for (name, value) in vec![
("Authorization", format!("Bearer {}", env::var("GRAPHOPS_API_KEY")?)),
] {
headers.insert(name.parse::<HeaderName>()?, value.parse()?);
}
let http = reqwest::Client::builder().default_headers(headers).build()?;
let provider = ProviderBuilder::new().connect_client(RpcClient::new(
Http::with_client(http, "https://rpc.graphops.xyz/v1/evm/1".to_string().parse()?),
false,
));
let result: Value = provider
.raw_request("eth_blockNumber".into(), json!([]))
.await?;
println!("{result}");
Ok(())
}
Usage on Ethereum Mainnet draws credits at the same rates as on every other network. Your monthly plan sets the price per credit.
1. Its CAIP-2 network ID is eip155:1.https://rpc.graphops.xyz/v1/evm/1, and open WebSocket connections to wss://rpc.graphops.xyz/v1/evm/1. Authenticate with an API key from your organization that includes RPC, in the Authorization header or as a route token at the end of the path.eth_call at a past block, and historical event logs are available on Ethereum Mainnet.network: mainnet in their manifest.https://1.evm.substreams.graphops.xyz over gRPC. Packages for Ethereum Mainnet declare mainnet as their network.eip155:11155111 eip155:560048 
eip155:8453 
eip155:100 Create an organization, choose your monthly credits, then create an API key that includes the services you need.