# zkVerify RPC Node  
ZK Verification

Connect to zkVerify, the modular verification layer for zero-knowledge proofs. Experience cost-efficient ZK proof verification enabling scalable rollup settlement.

[Documentation](https://docs-rpc.crypto-chief.com/) [Get a free endpoint ](https://auth.crypto-chief.com/registration)

##### 5 M+

Requests per Day

##### 99.99 %

Network Uptime

##### < 60 ms

Average Response Time

##### 24/7

Technical Support

## Specification zkVerify Network

Technical characteristics and available endpoints

![zkVerify](/img/protocols/zkverify.svg)

### zkVerify

Mainnet & Testnet Support

Type ZK Verification Layer

Protocol HTTPS / WSS

Uptime 99.99%

Focus Proof Verification

Proof Systems Multiple (SNARK, STARK, etc)

Architecture Modular Verification

zkVerify is a modular verification layer purpose-built for efficiently verifying zero-knowledge proofs from multiple proof systems and rollups. By separating proof verification from execution and providing specialized infrastructure optimized for cryptographic verification at scale, zkVerify dramatically reduces costs for ZK rollups settling proofs. Rather than each rollup paying expensive Ethereum gas to verify proofs on Layer 1, rollups batch verify through zkVerify achieving 90%+ cost reduction while maintaining cryptographic security. This creates essential infrastructure enabling economically viable ZK rollup scaling.

#### Key capabilities:

- Modular ZK proof verification
- Multi-proof-system support (SNARK, STARK, etc)
- 90%+ cost reduction vs L1 verification
- Batch verification optimization
- Cryptographic security guarantees
- Rollup-agnostic infrastructure
- High-throughput verification
- Substrate-based architecture
- Growing ZK ecosystem

#### 🔗 RPC Endpoints

HTTPS

`https://rpc.crypto-chief.com/zkverify/{YOUR_API_KEY}`

WSS

`wss://rpc.crypto-chief.com/zkverify/ws/{YOUR_API_KEY}`

Replace {YOUR\_API\_KEY} with your actual API key from the dashboard.

## What is a zkVerify RPC Node?

Access ZK verification infrastructure

A zkVerify RPC node provides applications with access to specialized infrastructure for verifying zero-knowledge proofs efficiently and cost-effectively. ZK rollups generate cryptographic proofs that their computation is correct, but verifying these proofs on Ethereum Layer 1 costs significant gas. zkVerify solves this economic challenge by providing optimized verification infrastructure where multiple rollups batch proofs together, amortizing costs across participants. This reduces per-rollup verification costs by 90%+ while maintaining cryptographic security guarantees essential for trustless rollup operation.

### Why ZK proof verification needs specialization

Verifying zero-knowledge proofs is computationally expensive — complex cryptographic operations consuming significant gas on general-purpose blockchains. Individual ZK rollups paying full verification costs face prohibitive economics preventing widespread adoption. **zkVerify provides specialized infrastructure** optimized exclusively for proof verification, enabling batch processing where multiple rollups share verification costs. This transforms ZK rollup economics from prohibitively expensive to economically sustainable.

**zkVerify advantages:**

- **90%+ cost reduction** — batch verification vs individual L1
- **Multi-proof support** — SNARK, STARK, and other systems
- **Specialized infrastructure** — optimized for verification
- **Cryptographic security** — maintains trustless guarantees
- **Rollup agnostic** — works with any ZK rollup
- **High throughput** — scales with growing ZK adoption

### Batch verification economics

**Batch verification** is zkVerify's key innovation — instead of each ZK rollup independently posting verification transactions to expensive Layer 1, zkVerify collects proofs from multiple rollups and verifies them together in batches. Fixed verification overhead gets amortized across all participating rollups, dramatically reducing per-rollup costs. Rollup paying $1000 for L1 verification might pay $50-100 on zkVerify for equivalent security — enabling sustainable ZK rollup economics.

**How batch verification works:**

1. Multiple ZK rollups submit proofs to zkVerify
2. zkVerify collects proofs into batches for verification
3. Specialized verifiers process batches efficiently
4. Verification costs amortized across all proofs in batch
5. Cryptographic proof of verification published
6. Rollups achieve 90%+ cost reduction vs L1 verification

### Multi-proof-system support

Different ZK rollups use different proof systems — some use SNARKs (Succinct Non-Interactive Arguments of Knowledge), others use STARKs (Scalable Transparent Arguments of Knowledge), and various other cryptographic schemes. **zkVerify supports multiple proof systems** providing unified verification infrastructure regardless of underlying cryptography. This proof-system-agnostic approach creates network effects — more rollups using zkVerify means better batch optimization and lower costs for everyone.

This infrastructure represents essential scaling layer enabling economically viable ZK rollup adoption.

## Technical Documentation

Quick start for developers

### Supported RPC Methods

zkVerify uses Substrate RPC methods with verification extensions:

- **chain\_getBlock** — retrieve block with verification data
- **chain\_getHeader** — get block header information
- **proof\_submit** — submit ZK proof for verification
- **proof\_verify** — verify submitted proof
- **proof\_getBatch** — query batch verification status
- **proof\_getCost** — estimate verification cost
- **attestation\_query** — get verification attestation
- **state\_subscribeStorage** — subscribe to verification events

### Code Examples

💻

#### JavaScript (Substrate) — Submit ZK Proof:

```
const { ApiPromise, WsProvider } = require('@polkadot/api');

// Connect to zkVerify
const provider = new WsProvider('wss://rpc.crypto-chief.com/zkverify/ws/YOUR_API_KEY');
const api = await ApiPromise.create({ provider });

console.log('Connected to zkVerify verification layer');
const chain = await api.rpc.system.chain();
console.log('Chain:', chain.toString());

// ZK Rollup submits proof for verification
const rollupProof = {
  proofSystem: 'PLONK',  // Or STARK, Groth16, etc.
  proof: '0x...', // Serialized ZK proof
  publicInputs: ['0x...'], // Public inputs for verification
  rollupId: 'my-zk-rollup'
};

// Submit proof to zkVerify
const submitTx = api.tx.proofVerification.submitProof(
  rollupProof.proofSystem,
  rollupProof.proof,
  rollupProof.publicInputs,
  rollupProof.rollupId
);

const hash = await submitTx.signAndSend(rollupAccount);
console.log('ZK proof submitted for batch verification!');
console.log('Transaction hash:', hash.toHex());

// Query verification status
const proofStatus = await api.query.proofVerification.proofStatus(hash);
console.log('Verification status:', proofStatus.toHuman());

// Get cost estimate (much cheaper than L1!)
const cost = await api.rpc.proofVerification.estimateCost(
  rollupProof.proofSystem,
  rollupProof.proof.length
);
console.log('Verification cost: ~90% cheaper than Ethereum L1!');
console.log('Estimated cost:', cost.toString(), 'ACME');
```

💻

#### Python (substrateinterface) — Batch Verification:

```
from substrateinterface import SubstrateInterface

# Connect to zkVerify
substrate = SubstrateInterface(
    url='wss://rpc.crypto-chief.com/zkverify/ws/YOUR_API_KEY'
)

print('Connected to zkVerify')
print('Chain:', substrate.chain)

# Query current batch
current_batch = substrate.query(
    module='ProofVerification',
    storage_function='CurrentBatch'
)

print(f'Current batch ID: {current_batch.value}')
print(f'Proofs in batch: {len(current_batch.value["proofs"])}')

# Submit ZK proof from rollup
rollup_proof_data = {
    'proof_system': 'Groth16',
    'proof': '0x...',
    'public_inputs': ['0x...'],
    'rollup_id': 'my-rollup'
}

call = substrate.compose_call(
    call_module='ProofVerification',
    call_function='submit_proof',
    call_params=rollup_proof_data
)

extrinsic = substrate.create_signed_extrinsic(
    call=call,
    keypair=rollup_keypair
)

receipt = substrate.submit_extrinsic(
    extrinsic,
    wait_for_inclusion=True
)

print('ZK proof submitted to batch!')
print('90%+ cost savings vs L1 verification!')

# Query verification attestation
attestation = substrate.query(
    module='ProofVerification',
    storage_function='VerificationAttestation',
    params=[receipt.extrinsic_hash]
)

if attestation.value:
    print('Proof verified successfully!')
    print('Cryptographic security maintained!')
```

💻

#### WebSocket — Monitor Verifications:

```
const { ApiPromise, WsProvider } = require('@polkadot/api');

const provider = new WsProvider('wss://rpc.crypto-chief.com/zkverify/ws/YOUR_API_KEY');
const api = await ApiPromise.create({ provider });

// Subscribe to verification events
api.query.system.events((events) => {
  events.forEach((record) => {
    const { event } = record;
    
    // Monitor proof submissions
    if (event.section === 'proofVerification' && event.method === 'ProofSubmitted') {
      console.log('\n=== ZK Proof Submitted ===');
      console.log('Rollup:', event.data[0].toString());
      console.log('Proof system:', event.data[1].toString());
      console.log('Added to batch for cost-efficient verification');
    }
    
    // Monitor batch verifications
    if (event.section === 'proofVerification' && event.method === 'BatchVerified') {
      console.log('\n=== Batch Verified ===');
      console.log('Batch ID:', event.data[0].toString());
      console.log('Proofs verified:', event.data[1].toNumber());
      console.log('Total cost shared across rollups!');
      console.log('90%+ savings achieved!');
    }
    
    // Monitor verification attestations
    if (event.section === 'proofVerification' && event.method === 'AttestationGenerated') {
      console.log('\n=== Verification Attestation ===');
      console.log('Proof hash:', event.data[0].toHex());
      console.log('Cryptographic verification complete!');
    }
  });
});

console.log('Monitoring zkVerify verification layer...');
```

### zkVerify Best Practices

- **Batch Optimization:** Submit proofs at optimal times for batch inclusion
- **Proof System Selection:** Choose appropriate ZK proof system for your rollup
- **Cost Monitoring:** Track verification costs and batch efficiency
- **Security Validation:** Verify cryptographic attestations from zkVerify
- **Fallback Plans:** Design rollup with fallback to L1 verification if needed
- **Integration Testing:** Thoroughly test proof submission and verification flow
- **Monitoring:** Track verification latency and success rates

## Why choose us?

ZK verification infrastructure

### Efficient Verification

Specialized infrastructure for ZK proof verification with &lt;60ms RPC latency and 90%+ cost reduction.

### Cryptographic Security

Production infrastructure maintaining trustless verification guarantees with 99.99% uptime.

### Verification Analytics

Comprehensive monitoring of proof submissions, batch verifications, costs, and throughput metrics.

### Global Infrastructure

Worldwide deployment supporting zkVerify's ZK rollup verification ecosystem.

### Throughput Scaling

Infrastructure designed to scale with growing ZK rollup adoption and proof verification demands.

### ZK Specialists

24/7 support from engineers specialized in zero-knowledge proofs, verification systems, and rollup infrastructure.

## Examples of Use

Build ZK rollups

zkVerify's modular verification layer enables cost-efficient ZK rollup development, multi-rollup platforms, and applications requiring scalable proof verification.

#### ZK Rollup Development

Build ZK rollups with 90%+ cost reduction on proof verification compared to direct Ethereum L1 settlement.

#### ZK DeFi Protocols

Launch ZK-powered DeFi with sustainable economics enabled by efficient batch verification.

#### ZK Gaming Rollups

Create gaming rollups with complex ZK proofs where verification costs would otherwise be prohibitive.

#### Privacy Applications

Develop privacy-preserving applications using ZK proofs with affordable verification infrastructure.

#### Multi-Rollup Platforms

Build platforms coordinating multiple ZK rollups sharing verification costs through zkVerify batching.

#### High-Throughput Rollups

Create rollups generating frequent proofs where verification cost efficiency is critical for viability.

## Got questions?  
we are here to help

## What is zkVerify? 

zkVerify is a modular verification layer providing specialized infrastructure for efficiently verifying zero-knowledge proofs from ZK rollups with 90%+ cost reduction.

## Why do ZK rollups need zkVerify? 

Verifying ZK proofs on Ethereum L1 is expensive. zkVerify reduces costs 90%+ through batch verification while maintaining cryptographic security.

## What is batch verification? 

Batch verification combines proofs from multiple rollups and verifies them together, amortizing fixed costs across participants for dramatic savings.

## Which proof systems does zkVerify support? 

zkVerify supports multiple ZK proof systems including SNARKs (PLONK, Groth16), STARKs, and other cryptographic verification schemes.

## How much cheaper is zkVerify vs L1? 

zkVerify provides 90%+ cost reduction compared to direct Ethereum L1 proof verification through optimized batch processing.

## Does zkVerify maintain security? 

Yes! zkVerify maintains cryptographic security guarantees — batch verification doesn't compromise trustless properties of ZK proofs.

## What is the ACME token? 

ACME is zkVerify's native token used for verification fees, network operations, and coordinating proof verification services.

## Can any ZK rollup use zkVerify? 

Yes! zkVerify is rollup-agnostic — any ZK rollup using supported proof systems can leverage zkVerify for cost-efficient verification.

## Do you support zkVerify testnet? 

Yes, we provide RPC access to both zkVerify mainnet and testnet for ZK rollup development and verification testing.

## Why is ZK proof verification expensive? 

ZK proof verification requires complex cryptographic computations consuming significant gas on general-purpose blockchains, making specialized infrastructure necessary.

## Pricing that grows with your needs.

### Free

Start building on Web3 — no credit card.

##### $0

- 5 reqs/sec RPC
- 5 reqs/min Unified API
- 1 req/day AML
- Ultimate chains
- WSS, Statistics
- Community support

[Get started ](https://auth.crypto-chief.com/registration)

### Pay for use

Flexible pay-as-you-go for any workload.

##### From $10

- 400 reqs/sec RPC
- 300 reqs/min Unified API
- 5 reqs/sec AML
- EventStream
- Ultimate chains
- WSS, Whitelists, Statistics
- Support portal

[Get started](https://auth.crypto-chief.com/registration)

### Subscription

From $500 monthly plus 20% extra value.

##### From $500

- 400 reqs/sec RPC
- 300 reqs/min Unified API
- 5 reqs/sec AML
- EventStream
- Ultimate chains
- WSS, Whitelists, Statistics
- Support portal

[Get started ](https://auth.crypto-chief.com/registration)

### Enterprise

Tailored solution for expert builders

##### Custom terms

All Subscription features plus:

- Flexible rate limits
- Engineering team support
- Custom SLA
- Personal manager

[Contact Sales ](/contact/)