Orthogonal Raises $4.3 Million to Connect AI Agents With Paid APIs and Instant Transactions

Orthogonal secured $4.3 million in seed funding on June 25, 2026, to expand its platform for AI agent service discovery, orchestration, and payments. Led by Pantera Capital with participation from Y Combinator, Pioneer Fund, and others, the startup builds infrastructure allowing autonomous AI agents to find, use, and pay for online services in real time. The platform currently integrates more than 35 APIs, allowing developer-built agents to execute multi-step workflows without human intervention.

Founders and Funding Syndicate

The $4.3 million seed round was led by Pantera Capital, with participation from Y Combinator, Pioneer Fund, Decasonic, Blast, Outbound, and Surreal. According to the company, the seed capital will be used to expand its core product engineering and scale its go-to-market teams. Based in San Francisco, Orthogonal builds core infrastructure to address the nascent agentic commerce market.

The company was co-founded by Bera Sogut and Christian Pickett, who serves as the co-founder and CEO of Orthogonal. Both founders bring deep backgrounds in payments and developer infrastructure. Pickett previously worked on payments at Coinbase and served as a technical lead on the billing platform team at Vercel, managing usage-based billing. Sogut worked on Google’s reCAPTCHA and Maps APIs and spent time engineering systems at Amazon Robotics. Their platform is already in production with go-to-market teams and AI-native startups.

The Friction of Human-Centric APIs in AI Agent Systems

Traditional web APIs are typically designed with human users in mind. They require manual registration, custom authentication keys, and corporate credit cards. When an autonomous AI agent encounters a task that requires an external API not hard-coded into its environment, the agent often fails, hallucinates, or requires human intervention.

To utilize multiple third-party tools, developers are forced to write custom integrations and manage dozens of API keys across separate vendor dashboards. This fragmented setup creates severe “context bloat,” meaning the agent must process extensive structural documentation simply to determine which tool to select. Orthogonal provides a single gateway that bypasses manual setup requirements, consolidating credentials, billing, and discovery into a single runtime environment.

Natural Language API Discovery and Multi-Step Orchestration

Developers integrate the platform directly using either a Software Development Kit (SDK) or a Model Context Protocol (MCP) server. An MCP is an open standard that defines how AI models securely connect to external tools and data sources. Instead of hard-coding exact tools, developers allow their agents to query Orthogonal’s catalog using plain-text search.

For example, an agent can search for an API to retrieve specific posts on X (formerly Twitter) or find a prospect’s email. Once the service is found, Orthogonal’s runtime coordinates the execution. It manages:

1. Rate limits across downstream providers
2. Automatic retries for failed requests
3. Dynamic routing to ensure the workflow finishes without human intervention

Integrating the SDK

Developers can install and run the Orthogonal SDK using the following pattern:

// Install: npm install @orth/sdk
import Orthogonal from "@orth/sdk";

const orthogonal = new Orthogonal({
  apiKey: process.env.ORTHOGONAL_API_KEY,
});

const output = await orthogonal.run({
  api: "apollo",
  path: "/api/v1/people/bulk_match",
  body: {
    "details": [],
    "webhook_url": "example"
  }
});

console.log(output);

Configuring the MCP Server

To integrate Orthogonal’s discovery tools directly into an MCP-compliant client (such as Cursor or Claude Desktop), developers add the following block to their configuration file:

{
  "mcpServers": {
    "orthogonal": {
      "url": "https://mcp.orth.sh"
    }
  }
}

The Orthogonal MCP server exposes specific tools to the agent, including:

• search: Find APIs by describing requirements in plain text.
• get_details: Fetch parameters for a specific endpoint.
• integrate: Retrieve code snippets.
• use: Execute an API call dynamically.

Resolving Agent Payments Through Machine-Native Protocols

AI agents cannot easily register corporate credit cards or negotiate enterprise contracts. To solve this, Orthogonal provides a unified billing system. Developers buy credits directly from Orthogonal, and the platform pays the downstream API providers per request, removing the need for individual billing relationships.

The transaction layer is built to support multiple payment rails:

• Traditional Fiat: Consolidates charges into a single invoice.
• x402 Protocol: Reuses the long-dormant HTTP 402 (“Payment Required”) status code, allowing agents to pay for web services dynamically in a single request.
• Machine Payments Protocol (MPP): An open-source payment standard developed for machine-native commerce.

To process these transactions, the startup is working with the Privy and Tempo teams. Privy is an acquired crypto wallet infrastructure company owned by Stripe, while Tempo is an independent payments-focused Layer 1 blockchain company incubated by Stripe and Paradigm.

Current API Integrations and Publisher Setup

The platform currently hosts more than 35 APIs, offering a growing directory of tools. Some of the notable data and discovery providers currently integrated include:

• Apollo (for contact enrichment)
• People Data Labs (for talent and company data)
• Coresignal (for labor market data)
• Olostep (for web scraping)
• Linkup (for live web data)

For API publishers, the system acts as a distribution channel. Providers list their API once to make it discoverable to any agent on the network, receiving automatic payouts per request without managing separate subscription models. Payout structures also support dynamic pricing models set by the providers.