Build trading and lending apps on Ink, the Ethereum layer 2 built by Kraken, with reliable HTTPS and WebSocket RPC.
Connect your application to Ink Mainnet over HTTPS and WebSocket. Read contract state, follow events, and submit signed transactions with familiar Ethereum tools.
Build Ink applications with archive state, execution traces, and predictable RPC capacity.
Run Ink indexers and application backends with unlimited requests within your selected RPS tier. Keep monthly RPC costs predictable as request volume grows.
Query historical contract state and backfill event logs for Ink indexers, accounting, and DeFi analytics.
Inspect Ink transaction execution, diagnose reverted calls, and investigate internal contract activity with debug APIs.
Read pool state, simulate calls, and submit signed swaps. Connect trading interfaces to Ink with ethers.js or viem.
Explore Ink tooling
Read collateral, debt, and market state from lending contracts. Follow protocol events to keep position dashboards current.
Get an Ink endpoint
Backfill logs with eth_getLogs and subscribe to new events over WebSocket. Use bounded block ranges for your historical indexer.
Read the Ink endpoint guide
Combine Kraken’s exchange APIs with Chainstack Ink RPC to compare exchange prices with onchain liquidity, monitor wallet funding, and track swaps.
Explore Ink tooling
Inspect transactions with op-reth debug and trace APIs on paid plans. Diagnose reverted calls and follow internal execution.
Explore Ink debug APIsChoose Ink mainnet and an available node configuration to estimate monthly infrastructure costs.
Choose an available Ink network and node configuration to estimate monthly infrastructure costs.
Customer stories from teams using Chainstack across supported networks.
Chainstack’s robust infrastructure has significantly enhanced our ability to secure Web3 environments effectively.Chainstack has been crucial in enhancing Brave Wallet’s multi-chain functionality and UX.The Unlimited Node flat-fee model gives us cost predictability, and the performance is rock-solidWe’ve gone from weekly incidents to zero incidents.Working with Chainstack helped us cut our infrastructure costs by over 70%, all while tackling intricate challenges in Web3 security.
Follow new blocks and contract logs over WebSocket, then backfill event history over HTTPS. Build trading, lending, and wallet workflows around confirmed receipts and the state your application needs.
Get an Ink endpointRead token-transfer events from the latest Ink block with eth_getLogs.
AI-ready infrastructure
Refer and earn
Ethereum
Hyperliquid
Solana
Arbitrum
BNB Smart Chain
Base
Polygon
TRON
Sui
Robinhood
SOC 2 Type II
ISO 27001
99.99%+ uptime
Learn more
https://ink-mainnet.core.chainstack.com/YOUR_ENDPOINT_IDwss://ink-mainnet.core.chainstack.com/YOUR_ENDPOINT_IDCreate an Ink node. Copy your authenticated HTTPS URL from Access and credentials and replace YOUR_ENDPOINT_ID in the example.
curl --request POST \
--url https://ink-mainnet.core.chainstack.com/YOUR_ENDPOINT_ID \
--header 'Content-Type: application/json' \
--data '{
"jsonrpc": "2.0",
"id": 1,
"method": "eth_getLogs",
"params": [
{
"fromBlock": "latest",
"toBlock": "latest",
"topics": [
"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
]
}
]
}'The result is an array of matching logs. Paginate historical backfills in bounded block ranges and filter by the contract addresses your application follows.
Start with free Ink RPC. Scale your application with paid plans, higher throughput, and dedicated infrastructure.
Includes:
All Developer features, plus:
Add-ons and Dedicated Node infrastructure are billed separately.
Exceptional support on every paid planSave over 50% on our elite Pay-as-you-go plan
Chat on Telegram (opens in a new tab)Explore Ink RPC, application development, and infrastructure guides.
Connect your wallet, application, or indexer to Ink.
Read article
Review endpoint features, pricing, and production tradeoffs.
Read article
Explore Kraken’s OP Stack L2 and its developer workflows.
Read article
Explore archive data, tracing, and managed node options.
Read article
Ink RPC connects applications to Ink through JSON-RPC over HTTPS or WebSocket. Read balances and contract state, retrieve event logs, and submit signed transactions. See Ink developer documentation.
Create a free Chainstack account, create a project, and deploy an Ink Global Node on mainnet. Copy your HTTPS or WebSocket URL from Access and credentials. The Developer plan includes 3 million request units per month, up to 25 requests per second, and one node. No credit card is required.
Your mainnet HTTPS URL follows https://ink-mainnet.core.chainstack.com/YOUR_ENDPOINT_ID. Copy the complete authenticated URL from your node and replace the example endpoint ID. See the Ink tooling guide.
Ink Mainnet uses chain ID 57073 (0xdef1). The gas currency is ETH. Use the chain ID matching your endpoint when configuring a wallet or signing transactions. See the official network details.
Chainstack currently serves Ink Mainnet. Ink Sepolia is a separate public test network, but it is not currently offered in Chainstack’s deployment matrix. Do not point a mainnet application at a testnet RPC URL. Check supported networks.
Yes. Configure your wallet or library with your Ink RPC URL and chain ID. Use HTTPS for JSON-RPC requests and your WSS URL for supported subscriptions such as new blocks and contract logs. Follow the Ink tooling guide.
Chainstack supports Ink archive access on mainnet. Archive state supports historical contract reads and analytics. Archive requests are billed at 2 request units; the exact classification depends on the method and block age. Archive access is available from Growth. See request-unit rules and supported network modes.
Use an Ink node with debug and trace APIs enabled on a paid plan. Ink runs op-reth and exposes debug_* and trace_*; tracer availability depends on the client. See Ink debug requirements.
Ink does not expose a public pending-transaction feed like Ethereum’s. Use transaction receipts, new-block subscriptions, and contract logs to follow confirmed activity. Ink also publishes a separate Subblocks stream for preconfirmations; it is not the same as a pending-transaction subscription. See the Ink RPC documentation.
Call eth_getLogs with a bounded block range and the event topics you need. ERC-20 transfers use the standard Transfer(address,address,uint256) event signature. Filter by contract address for a specific token, and paginate larger backfills. The request uses standard Ethereum-compatible event-log parameters.
Start with the free Developer plan. Paid plans start at $40 per month with annual billing. Unlimited Node adds flat-fee request capacity from Growth. Dedicated Nodes require Pro or above, with infrastructure billed separately. Compare current plan features.
No. Ink is Kraken’s EVM-compatible Ethereum Layer 2. The ink! language belongs to the Polkadot and Substrate smart-contract ecosystem. For Ink network configuration and Ethereum development tools, use the Ink tooling guide.
Connect to Ink Mainnet at https://ink-mainnet.core.chainstack.com/YOUR_ENDPOINT_ID. Copy the authenticated URL from Access and credentials. Mainnet uses chain ID 57073 and ETH for gas. Chainstack currently serves Ink Mainnet only. See the Ink tooling guide.
Use eth_getBalance for ETH balances, eth_call for contract reads, eth_getLogs for event history, and eth_sendRawTransaction for signed transactions. Connect over WebSocket for supported new-block and log subscriptions. Paginate event backfills and account for both L2 execution fees and L1 data fees. A pending tag is not a public mempool subscription. See Ink’s RPC behavior.
