?

Docs
OverviewAdvanced APIAIChains listVerifiable RPCAgent RPCFree Credits
Launch App

We Can't Read Your Queries. We Can't Fake Our Answers

Ankr Confidential RPC encrypts each JSON-RPC call in your SDK and opens it only inside an attested Intel TDX enclave on the node that answers. Ankr routes, rate-limits and bills the call but sees that you call, not what you ask. Every answer comes back signed by that node. Use the Verifiable RPC SDK with one option, or run its local proxy.

Talk to an ExpertRead the Docs
ByAnkr2.5B+daily requests70+blockchainsSOC 2 Type II
Confidential RPC · one eth_call, seen from both sides
What Ankr sees# outside the enclave: gateway, load balancer, Ankr logsPOST /arbitrum_vrpc/confidential?node_id=7f3a9c · message/ohttp-req · 0000200001000216441108230e5ec1dfcd58fc1fc2509da1f7fc84a2601ef850b58c7f43ae512088340ec8239922dfaa7e75chain arbitrum · 518 B in · 296 B out · 14:02:31 UTC · your API key · your IPcannot see: the method · its parameters · the result
Inside the enclavesealed# Intel TDX, attested{"jsonrpc":"2.0","id":7,"method":"eth_call","params":[{"to":"0xaf88d065e77c8cc2239327c5edb3a432268e5831","data":"0x70a08231000000000000000000000000f01de601b123c42c27d67c8f2d8e6b92f4a06689"},"latest"]}{"jsonrpc":"2.0","id":7,"result":"0x0000000000000000000000000000000000000000000000000000012b12894ed0"}# balanceOf for one of your addresses: readable here, nowhere else on Ankr's side→ sealed for your SDK alone, signed by the node key
opened only inside the enclave · signed by the attested node · checked by your SDK before it decrypts

Illustrative. Your calls stay sealed outside the enclave.

What You Get

Confidentiality Built Into Your RPC

Confidential RPC is JSON-RPC encrypted end to end between your application and one attested node: the call is opened and answered only inside a hardware-isolated enclave, and your SDK checks the hardware attestation before it sends anything.

Calls Sealed to the Node

Your SDK encrypts each request to the attested node's key. Ankr's network, gateway, logs and staff see encrypted bytes; only the enclave opens them.

Answers You Can Verify

The node signs every encrypted answer with its attested Ed25519 key. Your SDK checks the signature and the signer before it decrypts, and rejects anything altered.

One Option in Your SDK

Same Ankr API key, same endpoint as Verifiable RPC. ethers and viem take one option; any other stack, REST included, runs a small local proxy.

Standard Cryptography

Encryption follows IETF standards (HPKE, Oblivious HTTP message formats, Binary HTTP) on maintained open-source libraries. No home-grown crypto.

How Does Confidential RPC Work?

One mode of Verifiable RPC: on Ankr's side, your request exists in plaintext only inside the attested enclave of the node that answers it.

01

Your SDK Attests One Node

On first use the SDK asks for a fresh hardware attestation, checks the TDX quote and the exact node software, and pins that node. Its attested signing key, in X25519 form, is also its encryption key.
02

The Call Travels Sealed

The SDK encrypts each request to the pinned node. Ankr's gateway relays it byte for byte to that node only, with no fallback. It sees your API key, your IP, the chain, the node, sizes, status and timing.
03

The Enclave Answers, Signed

Inside the TEE a sidecar decrypts the request, calls the node, encrypts the answer so only your SDK can open it, and signs it. Your SDK checks the signature and the signer, then decrypts.

What Changes in Your Code?

01

Use the SDK

Install @w3tech.io/vrpc-ethers or @w3tech.io/vrpc-viem and set confidential: true, or use ConfidentialClient from @w3tech.io/vrpc-core. Same API key, same endpoint, same JSON-RPC.
02

Or Run the Proxy

Any other language or REST client: run vrpc-proxy in confidential mode next to your app and point your client at it. Nothing else changes.

Server-side and Node.js today. Browser apps calling the endpoint cross-origin are not supported yet.

What Confidential RPC Changes

Confidential RPC is Verifiable RPC with encryption switched on. The table shows what your provider can and cannot do in each case.

Commodity RPC
Verifiable RPC
Confidential RPC
Proof of who answered
None
Signed in the enclave, checked by your SDK
Signed in the enclave, checked by your SDK
Provider can read requests
Yes
Yes
No
Provider can read answers
Yes
Yes
No
Provider logs contain
Everything
Everything
That a call happened: key, chain, size, status and timing
Compromised load balancer or TLS edge
Can read and forge
Can read, cannot forge
Cannot read, cannot forge
What you integrate
An endpoint URL
The vRPC SDK or proxy
The same SDK or proxy, one setting on
Commodity RPC
Proof of who answered
None
Provider can read requests
Yes
Provider can read answers
Yes
Provider logs contain
Everything
Compromised load balancer or TLS edge
Can read and forge
What you integrate
An endpoint URL
Verifiable RPC
Proof of who answered
Signed in the enclave, checked by your SDK
Provider can read requests
Yes
Provider can read answers
Yes
Provider logs contain
Everything
Compromised load balancer or TLS edge
Can read, cannot forge
What you integrate
The vRPC SDK or proxy
Confidential RPC
Proof of who answered
Signed in the enclave, checked by your SDK
Provider can read requests
No
Provider can read answers
No
Provider logs contain
That a call happened: key, chain, size, status and timing
Compromised load balancer or TLS edge
Cannot read, cannot forge
What you integrate
The same SDK or proxy, one setting on

Shared or Your Own Node

Confidential RPCRolling out

Confidential mode on Ankr's Verifiable RPC platform. Your existing API key, the chain's vRPC endpoint, one SDK option.

  • Same API key and endpoint
  • Billed per call, like standard RPC
  • Rolling out across Verifiable RPC chains
Confidential DedicatedOn request

A single-tenant node for your chains, inside its own Intel TDX confidential VM on Ankr hardware, with the same confidential mode, SDK and attestation.

  • No other customer on your node
  • Chains and regions scoped with your contract
  • Enterprise add-on, quoted per setup
Talk to an Expert

Built for Teams Whose Queries Say Too Much

Exchanges & Custodians

Monitor deposit addresses and hot wallets without handing your provider a map of where the funds are.

Trading Desks, Market Makers & Funds

Simulate and poll the pools and contracts you trade without a log of what you were about to do.

Institutions & RWA Platforms

Give vendor-risk reviewers a mechanism instead of a policy: reads the provider cannot open, from an enclave they can attest.

Teams on Verifiable RPC

Same SDK, same endpoint: switch on one option and your verified reads become confidential too.

Wallet Backends

Keep your users' address-to-identity link out of your RPC provider's logs.

Agents & Strategy Bots

Encryption keeps the strategy out of the query stream; signatures keep forged data out of the agent.
One Node, Two Properties

Confidential and Verifiable, From the Same Node

Confidential RPC is a mode of Verifiable RPC on the same attested nodes. The enclave key that opens your request is the key that signs the answer, and in this mode the signature covers the encrypted request and response, so no hash of the plaintext appears on the wire. Your SDK checks the signature and the signer before it decrypts. One attested node gives you both properties: nobody in the path can read the question, and nobody in the path can alter the answer without your SDK noticing.
Intel TDXenclaveEd25519signatureOne nodedecrypts and signs
How Verifiable RPC works

Which Chains Does Confidential RPC Support?

Rolling Out Across Verifiable RPC Chains

Confidential mode runs on Ankr's Verifiable RPC nodes. The enclave sits at the infrastructure layer, not in the protocol, so the design holds for EVM and REST chains alike.
Confidential mode is live in demo phase on Ankr's production network and rolling out across Verifiable RPC chains. Tell us which chains you need first.
Talk to an Expert
Defense in Depth

How Confidential RPC Fits Your Security Stack

Your Own Nodes

full control · your data center
The strongest boundary, at the cost of running every chain yourself. Keep them where you have them; use Confidential RPC for the chains you don't.
Keep them

Transaction Privacy Tools

write path · private relays
Confidential RPC encrypts a transaction on its way to the node. Once the node broadcasts it, it is as public as any transaction on that chain. Keep your private relay for the write path.
Keep them
Confidential RPC

Confidential RPC

read path · managed · attested
Hardware isolation plus attestation you verify yourself, for the calls your systems make all day: sealed on the way in, signed on the way out.
Add it

What Can Ankr See?

Outside the enclave: Ankr can see

That you call: your API key, the chain, the node, your IP, timing, request and response sizes, the HTTP status and the number of calls in a batch.

ciphertext
Intel TDX enclaveInside the enclave: Ankr cannot see

What you ask and what comes back: the method, the parameters, the addresses, the result.

eth_calleth_getBalancesealed

We see that you call, not what you ask.

Hardware isolation and remote attestation are one layer in your defense in depth, not a reason to drop the others.

Open Where It Matters

The node-side sidecar (AGPL-3.0) and the client SDK (Apache-2.0) are public on GitHub, so you and your auditors can read exactly what encrypts your request and what opens it. Encryption follows IETF standards: HPKE (RFC 9180), Oblivious HTTP message formats (RFC 9458) and Binary HTTP (RFC 9292). Attestation follows the Verifiable RPC model, aligned with IETF RATS (RFC 9334).
Sidecar + SDKOpen source
EncryptionHPKE · OHTTP
AttestationIETF RATS RFC 9334
EnclaveIntel TDX + dstack

From Conversation to Confidential Production

  1. 01

    Talk

    30 minutes with our team: your chains, your read paths, your security review's questions.

  2. 02

    Early Access

    We enable Verifiable RPC for your API key on the chains you need; confidential mode is one SDK option on top.

  3. 03

    Integrate

    Switch on one option in the SDK, or run vrpc-proxy, and test it on your own read paths.

  4. 04

    Production

    The production demo is live. Customer production follows per agreement.

Confidential RPC is in its demo phase. Talk to us to get early access.

Frequently Asked Questions

Ankr Confidential RPC is a mode of Verifiable RPC that encrypts every JSON-RPC request and answer end to end between your application and one attested node running inside an Intel TDX enclave. Ankr's gateway still routes, rate-limits and bills each call but cannot read what was asked or answered, and every answer is signed by that node and checked by your SDK. It is live in demo phase on Ankr's production network and rolling out across Verifiable RPC chains.
That you call, not what you ask. Ankr sees your API key, your IP, the chain, the node that served you, when you call, request and response sizes, the HTTP status and how many calls a batch holds. It does not see the method, the parameters or the result. This is not anonymity: Ankr still knows who the customer is.
Only on the way to the node. A signed transaction is encrypted until the node receives it. Once the node broadcasts it, it is as public as any transaction on that chain. Confidential RPC does not offer MEV or front-running protection, so keep the private relay you use for the write path. A failed call can also be retried by the network and run twice, so make state-changing calls safe to repeat.
A policy is a promise about what the provider chooses not to keep. An enclave is a mechanism: your request is readable only inside it, and Ankr's logs and telemetry record that a call happened, never its content. Attestation lets you check the exact software that handles it. Ankr also holds SOC 2 Type II, which covers the organization's controls; attestation covers the specific node serving you.
We assume it can happen. Confidentiality toward the people who operate the machine rests on Intel TDX, with the same hardware trust and the same acknowledged physical-attack limits as Verifiable RPC. The design has no forward secrecy: traffic is encrypted to the node's long-term attested key, so if that key were ever extracted, recorded traffic to that node could be decrypted. Any node software version Ankr approves for that node can derive the same key. That is why we describe the protection as hardware isolation plus attestation you verify yourself, one layer in your defense in depth.
Very little. Set confidential: true in @w3tech.io/vrpc-ethers or @w3tech.io/vrpc-viem, use ConfidentialClient from @w3tech.io/vrpc-core, or run vrpc-proxy --confidential next to your app from any language, REST included. Your API key, endpoint and JSON-RPC payloads stay the same.
Verifiable RPC chains, as confidential mode rolls out. The production demo is live, and the design is chain-agnostic, REST chains included. Tell us which chains you need first.
Yes, on request. Confidential Dedicated gives you a single-tenant node for your chains inside its own Intel TDX confidential VM on Ankr hardware. It runs the same confidential mode, so your SDK attests and pins it exactly as on the shared platform. Chains, regions and pricing are scoped with your contract; talk to us for a quote.
Pricing is not set yet. During the demo each call, and each call inside a batch, counts as one request, like standard RPC. Talk to us about your volume.
Yes. Confidential RPC is a mode of Verifiable RPC, and in this mode the signature check is mandatory: your SDK checks the node's Ed25519 signature over the encrypted request and response, and that the signer is the attested node, before it decrypts. One attested node gives you both: nobody in the path can read the question, and nobody in the path can alter the answer unnoticed. The signature proves the answer came unaltered from the attested software; it does not replace a light client where you need consensus checks.
Encryption, attestation and signing add work on both ends. The attestation runs on first use and after a node change; after that there is no extra round trip per call. We do not publish benchmark numbers: a pilot on your own read paths measures the overhead before you go to production.
Ankr Confidential RPC

Bring Your Chains. We'll Bring the Enclave

Tell us which chains your systems read and what the reads control. We'll enable early access and help you wire the SDK or proxy into your stack.

  • 30-minute technical call
  • Early access for your API key
  • Reply within one business day
Contact Sales
Demo phase

Where It Stands

Rollout
Across Verifiable RPC chains
Production demo
Live since October 2026
Dedicated node
Confidential Dedicated on request

The Rest of Your Web3 Stack

Verifiable RPC

Signed responses your code verifies before acting on them.
Explore

Agent RPC

Token-optimized JSON-RPC for AI agents, with a live MCP server.
Explore

Enterprise RPC

Dedicated capacity, SLAs and regions for production scale.
Contact Sales