Starknet RPC Endpoints & API Access

It is the secure scaling technology bringing Ethereum’s benefits to the world.

Connect to Starknet RPC endpoints for wallet flows, contract apps, and live backends, with archive data where supported.

It is the secure scaling technology bringing Ethereum’s benefits to the world.

Create RPC Endpoint

Starknet RPC Endpoint

The below example uses the public API endpoint*. This endpoint is only suitable for testing. To avoid rate limiting and service interruption, sign up now to get your own API key.

Example CURL

curl -H 'content-type:application/json' -d '{"id": 1, "jsonrpc": "2.0", "method": "starknet_blockNumber"}' 'https://starknet.api.onfinality.io/public'

curl -H 'content-type:application/json' -d '{"id": 1, "jsonrpc": "2.0", "method": "starknet_blockNumber"}' 'https://starknet.api.onfinality.io/public'

HTTPs

https://starknet.api.onfinality.io/public

https://starknet.api.onfinality.io/public

Websocket

wss://starknet.api.onfinality.io/public-ws

wss://starknet.api.onfinality.io/public-ws

* The public endpoint is rate limited

RPC API Service

RPC API Features

Calculate Your Costs

Only pay for what you need.

Monthly Response Units

Million Standard Requests

0100M200M300M400M

Total Cost

$49/ month

Recommended Plan: GROWTH

Continue with this plan

Starknet RPC Endpoints on OnFinality

OnFinality provides managed Starknet RPC endpoints and API access for developers building on Starknet, a permissionless Validity-Rollup (ZK-rollup) for Ethereum. With OnFinality, you can connect to Starknet mainnet without running your own node, using authenticated endpoints designed for production workloads.

What is Starknet?

Starknet is a Layer 2 scaling solution for Ethereum that uses STARK cryptographic proofs to achieve high throughput, low transaction costs, and Ethereum-level security. It supports general computation through its native Cairo programming language, enabling complex dApps, DeFi protocols, and on-chain games. Starknet's native account abstraction and recursive proofs make it a powerful platform for scalable Web3 applications.

Why Use OnFinality for Starknet RPC?

Running a Starknet full node requires significant hardware and maintenance effort. OnFinality eliminates this overhead by offering:

Managed RPC endpoints: HTTP and WebSocket access to Starknet mainnet.
Archive data support: Access historical state for analytics and backends.
Observability: Request analytics and usage metrics for supported plans.
Scalable infrastructure: From shared endpoints to dedicated nodes where supported.

Common Use Cases for Starknet RPC

Developers use Starknet RPC endpoints for:

Wallet integrations: Query balances, send transactions, and interact with smart contracts.
dApp backends: Read on-chain data and submit user transactions.
DeFi products: Monitor liquidity, execute swaps, and manage positions.
Analytics tools: Index blockchain data for dashboards and reporting.
Games and NFTs: Fetch metadata, process game logic, and handle asset transfers.

How to Connect to Starknet with OnFinality

Create or sign in to your OnFinality account.
Select Starknet from the supported networks list.
Create an API endpoint (or deploy a dedicated node if available).
Test the endpoint using the starknet_blockNumber method.
Monitor request usage, errors, and limits before moving critical traffic.

Starknet RPC Key Facts

Network: Mainnet
Protocol: JSON-RPC over HTTP and WebSocket
Advanced access: Archive data available
Typical users: Production dApps, wallets, DeFi, analytics, games, bots

Comparison: Public vs OnFinality Starknet RPC

Public Starknet RPC endpoints are suitable for lightweight testing but often lack reliability and visibility for production use. OnFinality provides authenticated endpoints with clearer limits, request analytics, and a path to higher capacity.

Starknet RPC and developer resources

A useful Starknet RPC page should make the connection path, supported capabilities, and production planning trade-offs clear before a developer opens the dashboard.

Best fit: mainnet production workflows for wallet flows, contract apps, and live backends.

What builders usually check first:

Read current chain state for apps, dashboards, wallets, and backend services.
Submit transactions and monitor confirmations from Ethereum-compatible tools.
Query logs, receipts, and historical state when indexers or analytics pipelines need more than the latest block.
Debug contract behaviour with trace data where the network supports it.

Supported capability notes:

Authenticated Starknet RPC/API access for wallet flows, contract apps, and live backends.
Flexible HTTP and WebSocket access for app, backend, and integration workflows.
Archive-capable workflows when the product needs older chain state.

Decision notes:

Environment: mainnet. Protocol family: EVM JSON-RPC.
Flexible HTTP and WebSocket access is listed for supported app and backend workflows.
Archive support is available for historical state or older chain-data queries.

A quick connection check usually starts with starknet_blockNumber, then moves into the exact methods your wallet, dashboard, bot, indexer, or backend service needs.

Planning the next step:

Shared RPC is a practical starting point for integration, prototypes, dashboards, and many app backends.
If your product becomes traffic-heavy or operationally sensitive, review the available upgrade path before relying on a single access pattern.

Next steps: