Accepting Registrations for Alpha

Zero-Knowledge Proofs,
Delivered as a Service

Zero-knowledge proof generation for Web3 developers. A managed API, verifiable results, and pay-per-proof pricing.

Help shape the API around your proving workload.

What We Do

ZK Proving, Simplified

One API for the compute-intensive work behind zero-knowledge proofs. Bring your application logic; let managed proving handle the infrastructure.

Privacy Preserving

Prove the validity of computations without revealing sensitive inputs. Verifiers can check the proof without seeing the private witness data.

Built to Scale

On-demand proof generation that scales with demand, without managing your own proving infrastructure.

Developer First

A REST API and developer SDKs connect proof generation to your application, from submitting a job to retrieving its proof.

How It Works

From Computation to Verifiable Proof

Integrate zero-knowledge proofs into your application through a simple API workflow.

01

Submit

Send your computation and witness data to the Astrous API via a simple REST call.

02

Prove

A managed proving pipeline runs the supported circuit and generates its proof. GPU acceleration is a performance target.

03

Verify

Receive a compact, verifiable proof ready for on-chain submission or off-chain verification.

API design preview
import { Astrous } from '@astrous/sdk';

const client = new Astrous('your-api-key');

// Generate a ZK proof in one call
const proof = await client.prove({
  circuit: 'transfer-validity',
  inputs:  { sender: addr, amount: value },
  witness: privateData
});

// Verify on-chain or off-chain
const isValid = await client.verify(proof);
console.log(isValid); // true ✓

Simple and easy to adopt SDK interface. Integration assistance, documentation, and agent skills are available for alpha participants.

Why Astrous

Proving Infrastructure for Your Application

Spend your engineering time on application logic, with proof generation behind a consistent plug-and-play API.

Performance Focused

Proving latency, throughput, and cost per proof guide the work on acceleration and parallel execution.

Cost Efficient

Pay only for the proofs you generate, without maintaining dedicated proving infrastructure.

Developer First

A simple REST API and SDKs give Web3 developers an easy way to integrate zero-knowledge proofs.

Chain Agnostic

Verify proofs on-chain or off-chain, with integrations guided by developer needs and verifier compatibility.

Technology

A Focused Stack for ZK Applications

PLONK and Halo2 are our initial focus, with Groth16 and zkSTARKs planned for later. Compare proving options by application flexibility, compute costs, and on-chain verification costs.

Proving Systems

Gas-Optimized Proving (zkSNARKs)

For applications where on-chain verification costs matter.

  • PLONK
    Available in Alpha

    A balance of flexibility and verification costs for evolving applications. A universal setup can be reused across circuits within its size limits.

  • Groth16
    Planned for Beta

    Compact proofs and low on-chain verification costs for fixed circuits. Requires a trusted setup for each circuit.

Flexible & Recursive Proving

For complex computations and proof aggregation workflows.

  • Halo2
    Available in Alpha

    Flexible circuit design, with recursion and aggregation dependent on a chosen backend. IPAs avoid a trusted setup; KZG variants require one.

  • zkSTARKs
    Planned for Beta

    Transparent proving systems for large computations and rollup workloads. Larger proofs can increase on-chain verification costs.

Managed Proof Generation

REST API Developer SDKs GPU Acceleration

A managed proving API handles the compute behind each request, so developers can build without running their own prover.

Security & Verification

Proof Verification Circuit Testing

Verifiers check proofs without seeing any private witness data. The proving service processes that data to generate each proof. On-chain verification depends on the proving system and the target chain's verifier support.

About Astrous

Direct Access to the Builder

A focused engineering effort, with early developers helping set the priorities.

Founder

Sean Demers

I founded Astrous in June 2026 to make zero-knowledge proof generation easier to integrate into real applications. Astrous is bootstrapped, with our initial product having a focus on providing Web3 developers with automated PLONK and Halo2 proofs.

Alpha applicants can discuss their circuits, integration needs, and proving workloads directly with me.

Development

Built with Claude Code

API implementation and the initial PLONK and Halo2 proving work are underway. Claude Code supports that engineering work, from implementation and debugging to tests and technical documentation.

The first milestone is an end-to-end proving workflow: submit a job, generate a proof, and verify the result. Early developer feedback will guide API and SDK design.

Roadmap

From Core Development to Developer Access

A phased path from core proving systems to general availability.

Phase 1

Alpha Development

Core proving engine development focused on PLONK and Halo2, performance benchmarking, and API design.

Phase 2 — Current

Developer Onboarding

Alpha access shared as supported proving workflows are ready. Work directly with early developers on integrations, performance, and the SDK. Rapid development continues towards a public Beta.

Phase 3

Public Beta

Broader access, published integration documentation, and expanded verifier support informed by alpha feedback.

Phase 4

General Availability

Production availability with established reliability targets, usage-based billing, and support for larger deployments.

Ecosystem

Your Application, Your Ecosystem

Tell us where your proofs need to be verified. Alpha applications help prioritize chain integrations and verifier compatibility.

Alpha Participants

Bring Your Proving Workload

Register to work directly with Astrous on your ZK integration. Share what you’re building and where proof generation gets in the way.

The service is in active development. Access is granted as supported workflows are ready.

Your use case, proving system, or integration goals. A few sentences is enough.

Your email and project summary are saved to review your application and contact you about alpha access. Please leave out confidential details and PII.

To withdraw from the Alpha, email contact@astrous.dev.

✓

Application received

Thanks for sharing your project. We’ll review it for Alpha access.