8.6 Million Authentications Per Second:
Batch Processing at Scale

One thousand users authenticated in 116 microseconds. That's high-throughput authentication on a single node. This is the power of H33's batch authentication—enterprise-scale security that fits in your pocket.

The Scale Challenge

Modern applications face authentication demands that would have seemed impossible a decade ago:

• Social platforms: Billions of daily active users
• Gaming: Millions of concurrent players
• IoT: Trillions of device authentications
• Financial services: Millions of transactions per second

Traditional authentication systems crumble under this load. H33's batch processing was designed from the ground up for this scale.

How Batch Processing Works

Instead of processing authentications one at a time, batch mode groups requests and processes them in parallel:

// Sequential (slow) - DON'T DO THIS
for (const user of thousandUsers) {
  await h33.auth.verify(user);  // 1.28ms each = 220ms total
}

// Batch (fast) - DO THIS
const results = await h33.auth.batchVerify({
  users: thousandUsers,
  mode: 'parallel'
});
// 116µs total for all 1,000 users

The key optimizations that enable this performance:

• SIMD vectorization: Process multiple proofs simultaneously using CPU vector instructions
• Shared computation: Common cryptographic operations are computed once and reused
• Memory locality: Batch data is arranged for optimal cache performance
• Parallel verification: Independent verifications run across all available cores

Scaling Visualization

Real-World Use Cases

Massive multiplayer games: Authenticate all players in a game server instance simultaneously when the match starts.

Workforce logins: Process morning login waves for entire enterprises in milliseconds.

IoT device fleets: Verify thousands of sensor readings in a single batch operation.

Event ticketing: Authenticate concert or sports event attendees as they arrive.

Implementation Patterns

// Pattern 1: Streaming batch
const batchProcessor = h33.createBatchProcessor({
  maxBatchSize: 1000,
  maxWaitMs: 10,  // Collect for up to 10ms
});

// Requests are automatically batched
app.post('/verify', async (req, res) => {
  const result = await batchProcessor.add(req.body);
  res.json(result);
});

// Pattern 2: Explicit batching
const pendingRequests = collectRequests(timeWindow);
const results = await h33.auth.batchVerify({
  users: pendingRequests,
  mode: 'parallel',
  continueOnError: true  // Don't fail batch on single error
});

// Pattern 3: Scheduled batch
cron.schedule('*/5 * * * * *', async () => {
  const queuedAuth = await getQueuedAuthRequests();
  if (queuedAuth.length > 0) {
    await h33.auth.batchVerify({ users: queuedAuth });
  }
});

Batch ZK Proofs

Batch processing extends to ZK proof generation as well:

• 100 proofs: 35ms (73% faster than sequential)
• Proof aggregation: Multiple proofs combined into single verification
• Recursive composition: Proofs of proofs for unlimited scale

Cost Efficiency

Batch processing doesn't just improve performance—it reduces costs:

• Compute: 1,900x fewer CPU cycles per authentication
• Memory: Shared buffers reduce memory allocation
• Network: Single request replaces thousands
• Billing: H33 batch operations are priced per batch, not per user