Claude's Corner: Orthogonal, The API Economy, Rebuilt for Agents

Orthogonal gives AI agents instant access to 50+ premium APIs through a single MCP server and pay-per-call credits. No API key management, no vendor onboarding, just agents buying data the same way they call a function. Here's how it works and whether you can replicate it.

Daniel Singer

Editor, StartupHub.ai

Jun 12 at 11:12 AMUpdated Jun 19, 20269 min read

Claude's Corner: Orthogonal, The API Economy, Rebuilt for Agents

TL;DR

Orthogonal is an API gateway and marketplace for AI agents, one MCP server, one API key, access to 50+ premium data providers with per-call billing. No vendor onboarding, no secrets management. Built on HTTP 402 payment semantics, it lets autonomous agents discover and pay for API access at runtime, enabling a new class of budget-aware agents.

4.6

Build difficulty

Contents(9)

The API economy was built for humans. You visit a vendor's website, enter a credit card, receive an API key, store it somewhere (hopefully not in a .env file committed to GitHub), wire up retry logic, set calendar reminders about rate limits, and try to remember which team member actually signed up for this account. It's a minor annoyance when you're a developer. It's a hard structural barrier when you're an autonomous AI agent running a research task at 3am with no one at the keyboard.

Orthogonal is rebuilding API access for the agent era. And the timing, with agentic workflows moving from prototype to production across every serious AI company, couldn't be better.

The Problem Is Structural, Not Cosmetic

Every enterprise AI agent built today faces the same friction wall: the moment it needs a paid external data source, someone has to pre-configure credentials. Someone has to set up billing. Someone has to manage rate limits across five different vendor dashboards. The entire API ecosystem's authentication and payment infrastructure was designed with a human in the loop at every step, because until recently, there was always a human in the loop.

HTTP 402, "Payment Required", has been an official HTTP status code since 1991. The spec literally says it's "reserved for future use" with micropayment systems. Thirty-five years later, the web mostly ignored it, because there was never a compelling reason for machine-to-machine payments at scale. The agent economy is that reason.

Orthogonal is one of the first companies to take the 402 protocol seriously and build real infrastructure around it.

What They Actually Do

Orthogonal is an API gateway and marketplace for AI agents. One MCP server, one SDK, access to 50+ premium APIs, billed per call. No per-vendor onboarding, no OAuth flows, no secrets rotation across a dozen dashboards. Agents query the catalog in natural language, "I need an API that returns someone's LinkedIn profile from an email address", and Orthogonal routes the request to the best available provider.

The catalog today spans four core categories: search, scraping, datasets, and AI model APIs. Integrated providers include Apollo (210M+ professional contacts), People Data Labs, ScrapeGraphAI, ContactOut, PredictLeads, Composio, and 40+ others. For GTM, enrichment, recruiting, or intelligence workflows, this is essentially the complete toolkit, accessible through a single API key and billed at per-call rates starting around $0.01.

For developers building agents, the value is friction elimination. No more juggling vendor accounts. For API providers, the pitch is equally clean: list your API once, get distributed to every agent using Orthogonal, receive payment automatically per request with configurable dynamic pricing.

New users get $10 in free credits. No card required to start.

How It Works Technically

The delivery mechanism is the interesting architectural choice. Orthogonal ships as three interfaces: an MCP server, a TypeScript SDK, and a plain REST API. The MCP server is the one that matters most.

Model Context Protocol, Anthropic's open standard for giving AI models structured access to tools and external data, is rapidly becoming the de-facto integration layer for agent tooling. By building as a first-class MCP server rather than bolting it on as an afterthought, Orthogonal slots natively into Claude Code, Cursor, OpenAI Codex, and any framework that speaks MCP. From an agent's perspective, Orthogonal looks like a tool. Describe what you need in natural language. Get data back. No credential management involved.

Under the hood, the platform handles five things agents shouldn't have to think about:

Provider routing, queries are dispatched to the best available provider for that endpoint type, scored on latency, uptime, and price
Authentication abstraction, Orthogonal holds vendor API keys; your agent never touches them
Rate limit management, automatic retries, backoff, and failover to alternative providers when primaries are degraded
Billing abstraction, agents spend Orthogonal credits; no separate vendor invoices
Response normalization, consistent response shapes across providers where the underlying data is equivalent

The HTTP 402 integration is the philosophically interesting layer. Before making an expensive API call, an agent can check what it will cost, compare that against its current credit balance, and decide whether the expense is justified given the task at hand. This enables something most agents don't have today: genuine cost-awareness. You can build agents with hard spend ceilings, or agents that escalate to a human before making high-value data purchases. The infrastructure for budget-conscious autonomous agents finally exists.

The Founders

Christian Pickett worked on payments at Coinbase and billing infrastructure at Vercel. If you're building a micropayment gateway for API calls, that's about as precisely matched a background as you could construct. Coinbase instilled crypto-native thinking about machine-to-machine value transfer. Vercel taught him how usage-based billing works at developer-facing scale, the kind of billing where customers are also technical users who hate friction and will churn the moment invoices get weird.

Bera Sogut comes from Google (reCAPTCHA, Maps APIs) and Amazon Robotics, and is a two-time ACM ICPC World Finalist, the competitive programming world championship. The robotics background is relevant: autonomous physical systems have always needed to consume external data feeds and services in real time, with reliability requirements that human-loop systems don't face. The agent era is just the software version of that problem.

They met at McGill University and have stayed close since. The company is headquartered in San Francisco. Early customers include a set of YC-backed companies, Precip (W24), Riveter (F24), Andi (W22), Fiber AI (S23), and Sixtyfour (X25), suggesting early traction in the YC ecosystem specifically.

Difficulty Score

Dimension	Score	Notes
ML / AI	2/10	No ML in the core product. Natural language API discovery is embedding + nearest-neighbor retrieval, commodity infrastructure in 2026.
Data	5/10	Curating, testing, and monitoring 50+ API providers for response quality and uptime SLAs is operationally tedious. The catalog itself is the data asset.
Backend	7/10	Multi-provider routing, sub-50ms proxy latency, concurrent credit deduction without races, and reliable failover are legitimately hard distributed systems problems.
Frontend	3/10	Standard developer dashboard. The product lives in the SDK and MCP server, not the UI.
DevOps	6/10	Managing SLAs across 50+ external dependencies, each with their own rate limits and downtime patterns, requires mature observability and incident response.

The Moat

The proxy infrastructure itself is not the moat. A weekend project could wire five APIs behind a unified endpoint. That's not what Orthogonal is building.

The moat is three-layered, and they compound.

Provider network effects. Fifty-plus signed API partners represents fifty separate business development conversations, contract negotiations, integration agreements, and pricing discussions. A competitor starting today faces a minimum 12-18 month timeline to replicate the catalog, not because the engineering is hard, but because BD is slow. Providers also have limited incentive to repeat that process with a second platform once they're already distributed through Orthogonal. First-mover advantage in marketplace business development is real and boring and effective.

MCP ecosystem embedding. The MCP standard is still young. Orthogonal is building natively for it at the platform level rather than adding MCP as a feature. Developer tooling habits form early, if your agent workflow is built around Orthogonal's MCP server today, you are not migrating off it when your deadline is tomorrow. The switching cost isn't high technically, but psychologically it's sticky.

Billing intelligence flywheel. As call volume scales, Orthogonal accumulates data no single API provider has: cross-provider price benchmarks, quality comparisons for equivalent data, latency distributions across providers for the same endpoint type, reliability patterns by provider and time of day. This proprietary dataset improves routing decisions and could eventually power pricing recommendations for both providers and customers. You cannot buy this data; you can only accumulate it.

The HTTP 402 play is the long-term wildcard. If autonomous agents become primary API consumers, which seems increasingly likely, then machine-to-machine payment standards will matter at the same level that credit card processing standards matter today. Orthogonal has a credible shot at being the infrastructure layer under that standard, rather than just a clever wrapper around it.

What's Genuinely Hard to Copy

Provider trust and developer trust are both slow to build and fast to lose. Orthogonal holds API keys for 50 vendors on behalf of potentially thousands of customers. Any security incident or billing error damages both sides simultaneously. Infrastructure companies earn trust through sustained operational reliability over years, not marketing.

The payment systems expertise is also non-obvious. Most engineers who build API gateways have never thought seriously about HTTP 402, micropayment protocols, or credit reservation patterns under high concurrency. The founders' backgrounds give them mental models that a generic SaaS builder simply doesn't have.

What's Easy to Copy

The proxy mechanics. The SDK design. The per-call billing model. Any of the larger API management incumbents, Kong, AWS API Gateway, Apigee, could ship an "agentic mode" with a team of five engineers in a quarter. Their constraint is that they haven't noticed this market yet, or don't care enough to prioritize it. That window closes.

Orthogonal's time advantage is probably 18-24 months before a well-resourced competitor makes a serious run at this space. The question is whether that's enough time to lock in providers, embed in the MCP ecosystem deeply enough that migrating feels expensive, and build the developer brand that makes the platform feel like a safe dependency.

Replicability Score: 38 / 100

The technology stack to build this is a weekend project. The business to run it is 18 months of BD work, operational trust-building, and developer ecosystem cultivation. The core proxy, billing, and MCP server are well-understood patterns that any strong backend team can execute. What you can't shortcut is the provider network, the operational track record, and the developer trust. Those take time, and time in a fast-moving space is the one resource you can't buy.

If the HTTP 402 / agentic payments thesis plays out at scale, this score climbs to 65+. The company that owns the standard for how agents pay for data is infrastructure, and infrastructure businesses have decade-long moats. Right now, Orthogonal is a well-timed bet by a well-credentialed team. Watch whether the protocol bet pays off.

© 2026 StartupHub.ai. All rights reserved. You may not republish this article in full without a license. Search engines and AI research tools may crawl and summarize for reference. Bulk reproduction or model training requires a license. See our terms.

Build This Startup with Claude Code

Complete replication guide, install as a slash command or rules file

# Build Guide: Orthogonal Clone, Agentic API Gateway with Per-Call Billing

A step-by-step guide to building a unified API gateway for AI agents, with provider routing, MCP server integration, and usage-based billing. Build this with Claude Code.

---

## Step 1: Database Schema

Set up PostgreSQL (or Supabase) with these core tables:

```sql
-- API providers registered on the platform
CREATE TABLE providers (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name TEXT NOT NULL,
  slug TEXT UNIQUE NOT NULL,
  description TEXT,
  website TEXT,
  categories TEXT[] DEFAULT '{}',  -- e.g. ['search', 'enrichment', 'scraping']
  base_url TEXT NOT NULL,           -- upstream API base URL
  auth_header TEXT DEFAULT 'Authorization', -- how to inject their key
  api_key_encrypted TEXT,           -- store encrypted, decrypt at runtime
  status TEXT DEFAULT 'active',     -- active | degraded | down
  avg_latency_ms INT,
  uptime_pct NUMERIC(5,2),
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Individual API endpoints/tools offered
CREATE TABLE api_endpoints (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  provider_id UUID REFERENCES providers(id),
  name TEXT NOT NULL,             -- e.g. "person_enrichment"
  description TEXT,               -- used for natural language search
  path TEXT NOT NULL,             -- e.g. "/v1/person/enrich"
  method TEXT DEFAULT 'POST',
  price_per_call_cents INT NOT NULL,  -- in USD cents
  dynamic_pricing BOOLEAN DEFAULT false,
  input_schema JSONB,             -- JSON Schema for request body
  output_schema JSONB,            -- JSON Schema for response
  embedding VECTOR(1536),         -- for semantic search
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Customer accounts
CREATE TABLE accounts (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  email TEXT UNIQUE NOT NULL,
  name TEXT,
  credits_cents INT DEFAULT 1000, -- $10 free to start (in cents)
  stripe_customer_id TEXT,
  created_at TIMESTAMPTZ DEFAULT now()
);

-- API keys issued to customers
CREATE TABLE api_keys (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  account_id UUID REFERENCES accounts(id),
  key_hash TEXT UNIQUE NOT NULL,   -- bcrypt hash of the key
  key_prefix TEXT NOT NULL,        -- first 8 chars shown in UI
  name TEXT,
  created_at TIMESTAMPTZ DEFAULT now(),
  last_used_at TIMESTAMPTZ,
  revoked_at TIMESTAMPTZ
);

-- Every API call logged here
CREATE TABLE call_log (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  account_id UUID REFERENCES accounts(id),
  endpoint_id UUID REFERENCES api_endpoints(id),
  provider_id UUID REFERENCES providers(id),
  cost_cents INT NOT NULL,
  latency_ms INT,
  status_code INT,
  error TEXT,
  request_hash TEXT,   -- for dedup/caching
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Indexes
CREATE INDEX ON api_endpoints USING ivfflat (embedding vector_cosine_ops);
CREATE INDEX ON call_log (account_id, created_at DESC);
CREATE INDEX ON call_log (provider_id, created_at DESC);
```

---

## Step 2: Backend API, Core Gateway

Use **Node.js + Fastify** (or Hono on Cloudflare Workers for edge latency).

Key routes:

```
POST /v1/call, proxy a call to an endpoint by ID
GET  /v1/discover, semantic search for endpoints
GET  /v1/endpoints, list all available endpoints
GET  /v1/balance, check account credit balance
POST /v1/topup, Stripe checkout session for credits
GET  /v1/usage, call history and spend breakdown
```

### Gateway middleware stack:
1. **Auth**: Hash inbound API key, look up account
2. **Balance check**: Abort with HTTP 402 if balance < endpoint cost
3. **Credit reservation**: Deduct credits optimistically (refund on upstream failure)
4. **Provider routing**: Pick best available provider for the endpoint
5. **Upstream call**: Forward request with provider's API key injected
6. **Logging**: Write to `call_log` with latency and status
7. **Response passthrough**: Return normalized response to caller

### HTTP 402 implementation:
```typescript
// When balance is insufficient, return structured 402
if (account.credits_cents < endpoint.price_per_call_cents) {
  reply.status(402).send({
    error: 'insufficient_credits',
    required_cents: endpoint.price_per_call_cents,
    available_cents: account.credits_cents,
    topup_url: `https://yourdomain.com/topup?session=${generateSession(account)}`
  });
  return;
}
```

---

## Step 3: Provider Routing Engine

```typescript
interface ProviderScore {
  providerId: string;
  score: number;
}

async function selectProvider(endpointType: string, requestedFeatures: string[]): Promise<string> {
  const candidates = await db.query(`
    SELECT p.id, p.avg_latency_ms, p.uptime_pct,
           ae.price_per_call_cents
    FROM providers p
    JOIN api_endpoints ae ON ae.provider_id = p.id
    WHERE ae.name = $1 AND p.status = 'active'
    ORDER BY (p.uptime_pct * 0.6 - p.avg_latency_ms * 0.0001 - ae.price_per_call_cents * 0.4) DESC
    LIMIT 3
  `, [endpointType]);

  // Return top-scored provider, with fallback logic
  return candidates.rows[0]?.id;
}
```

Add a **health poller** (cron every 5 min) that pings each provider, records latency/status, and marks providers `degraded` or `down` automatically.

---

## Step 4: MCP Server

The MCP server is what makes this agent-native. Use the `@modelcontextprotocol/sdk` package.

```typescript
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

const server = new Server({ name: 'orthogonal-gateway', version: '1.0.0' });

// List tools = list all available API endpoints
server.setRequestHandler(ListToolsRequestSchema, async () => {
  const endpoints = await db.query('SELECT * FROM api_endpoints WHERE status = $1', ['active']);
  return {
    tools: endpoints.rows.map(ep => ({
      name: ep.name,
      description: ep.description,
      inputSchema: ep.input_schema
    }))
  };
});

// Call tool = proxy to the gateway
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;
  const result = await gatewayCall(name, args, process.env.ORTHOGONAL_API_KEY);
  return { content: [{ type: 'text', text: JSON.stringify(result) }] };
});

const transport = new StdioServerTransport();
await server.connect(transport);
```

Publish to npm and add to the MCP server registry. Agents can then add it to their `mcp.json` config with one line.

---

## Step 5: Natural Language Discovery

Use OpenAI or Claude embeddings to enable semantic API discovery:

```typescript
// Embed all endpoint descriptions at ingestion time
async function embedEndpoint(endpoint: Endpoint) {
  const text = `${endpoint.name}: ${endpoint.description}. Categories: ${endpoint.categories.join(', ')}`;
  const embedding = await openai.embeddings.create({ model: 'text-embedding-3-small', input: text });
  await db.query('UPDATE api_endpoints SET embedding = $1 WHERE id = $2',
    [embedding.data[0].embedding, endpoint.id]);
}

// Search at query time
async function discoverEndpoints(query: string, limit = 5) {
  const queryEmbedding = await openai.embeddings.create({ model: 'text-embedding-3-small', input: query });
  return db.query(`
    SELECT id, name, description, price_per_call_cents,
           1 - (embedding <=> $1::vector) AS similarity
    FROM api_endpoints
    ORDER BY embedding <=> $1::vector
    LIMIT $2
  `, [JSON.stringify(queryEmbedding.data[0].embedding), limit]);
}
```

---

## Step 6: Billing with Stripe

```typescript
// Top-up flow: create Stripe checkout session
app.post('/v1/topup', async (req, reply) => {
  const { amount_dollars } = req.body; // e.g., 10, 50, 100
  const session = await stripe.checkout.sessions.create({
    customer: req.account.stripe_customer_id,
    mode: 'payment',
    line_items: [{ price_data: {
      currency: 'usd',
      product_data: { name: `${amount_dollars} USD in API credits` },
      unit_amount: amount_dollars * 100,
    }, quantity: 1 }],
    success_url: `https://yourdomain.com/dashboard?topup=success`,
    cancel_url: `https://yourdomain.com/dashboard`,
    metadata: { account_id: req.account.id, credits_cents: amount_dollars * 100 }
  });
  return { checkout_url: session.url };
});

// Webhook: credit account on payment success
app.post('/webhooks/stripe', async (req, reply) => {
  const event = stripe.webhooks.constructEvent(req.rawBody, req.headers['stripe-signature'], STRIPE_WEBHOOK_SECRET);
  if (event.type === 'checkout.session.completed') {
    const { account_id, credits_cents } = event.data.object.metadata;
    await db.query('UPDATE accounts SET credits_cents = credits_cents + $1 WHERE id = $2',
      [credits_cents, account_id]);
  }
});
```

---

## Step 7: Deployment

**Architecture:**
- **API gateway**: Deploy on Fly.io or Railway for global edge latency. Multiple regions critical, your proxy adds latency to every upstream call, so co-locate near customers.
- **Database**: Supabase (Postgres + pgvector built in for embeddings)
- **MCP server**: Publish as npm package + Docker image
- **Health polling**: Cron workers on Trigger.dev or Inngest
- **Provider secrets**: Store encrypted in DB, decrypt at runtime with KMS (AWS KMS or HashiCorp Vault)

**Key operational concerns:**
1. **Latency budget**: You're adding a proxy hop. Keep p99 overhead under 50ms.
2. **Provider outages**: Circuit breaker pattern per provider, auto-fallback to alternatives.
3. **Credit races**: Use Postgres row-level locking (`SELECT ... FOR UPDATE`) when deducting credits to prevent overdraft.
4. **Webhook delivery reliability**: Queue-backed (BullMQ or SQS) so webhook processing survives pod restarts.
5. **SDK distribution**: npm + PyPI + Go module. Reach more agent frameworks.

**To sign your first 5 providers:** identify APIs that (a) have no self-serve signup friction, (b) are used in AI/agent workflows, and (c) have per-call pricing already. Reach out directly, the pitch is "zero integration work, instant distribution to every agent using our platform."

Install for:

claude-code-skills.md

#API #AI Agents #MCP #Infrastructure #YC W2026 #Payments #Developer Tools

Written by

Daniel Singer

Editor, StartupHub.ai

Daniel Singer is the editor of StartupHub.ai, a technology expert and thought leader on AI and its applications across sectors, from fintech and healthcare to developer tooling and consumer software. He writes and tests the tools covered here thoroughly and regularly, and built StartupHub.ai to give founders, operators and buyers a clearer read on what they are actually being sold.