Seltz is now on Orthogonal: real-time web knowledge for AI agents

Seltz is now live on Orthogonal. If you're building agents, you can pull real-time, source-backed web knowledge into your context with one API key, pay per call, and skip the usual account setup. No Seltz signup required to get started — though you're welcome to create one if you want direct access.

This is the first distribution surface we've partnered on, and it fits exactly where Seltz belongs: in the hands of developers building the next generation of agents.

The problem Orthogonal solves

AI agents are becoming the biggest consumers of APIs on the internet, but the entire API economy was built for humans. Sign up, verify email, create an account, generate a key, put a card on file, manage rate limits, rotate credentials. Repeat that across a dozen providers and you've spent a sprint on plumbing before your agent does anything useful.

Orthogonal collapses that. One key, one SDK, hundreds of APIs, pay-per-request billing. Agents can discover, call, and pay for tools without a human in the loop. That's the shape of the world we think agents will actually live in, and it's why we wanted Seltz in the catalog from day one.

What you get when you call Seltz on Orthogonal

Structured documents, not links. A Seltz query returns full document content with source URLs — not ten blue links and not 160-character snippets. Feed the results directly into your LLM context window. No HTML parsing, no scraping pipeline, no post-processing.

Real-time web data. The web Seltz sees is the web as it exists right now. Ask about something that happened this morning and get back sourced results from this morning. No stale training data, no cached snapshots from last quarter.

One key, pay per call. Use your existing Orthogonal API key. No separate Seltz account, no subscription, no minimum commitment. Run one query or one million — you pay for what your agent actually uses.

x402 support for agent-native payments. If your agents pay autonomously in USDC via the x402 protocol, Seltz works out of the box. No API keys to rotate, no billing to reconcile. The agent pays the API directly, per request.

Calling Seltz with the Orthogonal SDK

Install the SDK, pass your Orthogonal key, and you're live:

import Orthogonal from "@orth/sdk";

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

const result = await orthogonal.run({
  api: "seltz",
  path: "/v1/search",
  body: {
    query: "latest AI funding rounds this week",
    max_results: 10
  }
});

// Each document has full content and a source URL — ready for LLM context
for (const doc of result.documents) {
  console.log(doc.url);
  console.log(doc.content);
}

import Orthogonal from "@orth/sdk";

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

const result = await orthogonal.run({
  api: "seltz",
  path: "/v1/search",
  body: {
    query: "latest AI funding rounds this week",
    max_results: 10
  }
});

// Each document has full content and a source URL — ready for LLM context
for (const doc of result.documents) {
  console.log(doc.url);
  console.log(doc.content);
}

import Orthogonal from "@orth/sdk";

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

const result = await orthogonal.run({
  api: "seltz",
  path: "/v1/search",
  body: {
    query: "latest AI funding rounds this week",
    max_results: 10
  }
});

// Each document has full content and a source URL — ready for LLM context
for (const doc of result.documents) {
  console.log(doc.url);
  console.log(doc.content);
}

That's the whole integration. No parsing, no enrichment step, no "clean up the HTML before you feed it to the model." The documents come back shaped the way an LLM wants to consume them.

Calling Seltz with x402

If your agents are paying per-call in USDC, skip the API key entirely:

import { wrapFetchWithPayment } from "x402-fetch";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.PRIVATE_KEY);
const fetchWithPayment = wrapFetchWithPayment(fetch, account);

const response = await fetchWithPayment(
  "https://x402.orth.sh/seltz/v1/search",
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      query: "best ai search engines",
      max_results: 10
    })
  }
);

const data = await response.json();

import { wrapFetchWithPayment } from "x402-fetch";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.PRIVATE_KEY);
const fetchWithPayment = wrapFetchWithPayment(fetch, account);

const response = await fetchWithPayment(
  "https://x402.orth.sh/seltz/v1/search",
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      query: "best ai search engines",
      max_results: 10
    })
  }
);

const data = await response.json();

import { wrapFetchWithPayment } from "x402-fetch";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.PRIVATE_KEY);
const fetchWithPayment = wrapFetchWithPayment(fetch, account);

const response = await fetchWithPayment(
  "https://x402.orth.sh/seltz/v1/search",
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      query: "best ai search engines",
      max_results: 10
    })
  }
);

const data = await response.json();

The payment handshake happens on the wire. Your agent hits the endpoint, x402 handles the USDC transfer, Seltz returns the results. No subscription, no key management, no human in the loop.

What teams are building with it

• Research agents that answer questions about things that happened today, with citations back to the sources they pulled from

• RAG pipelines that need fresh, grounded web context alongside whatever private knowledge base they're built on

• Monitoring and analytical tools that pull current statistics, pricing, regulations, or specs on demand

• Any system where "what is true right now" matters more than "what was in the training data"

The common thread: agents that need to reason over live information without the integration tax of standing up their own search and scraping stack.

Why we partnered with Orthogonal

Agents don't browse the web the way humans do, and they shouldn't have to pay for APIs the way humans do either. Orthogonal is one of the few teams building the payment and discovery layer that agent-native software actually needs — and bring the right background for it, between Coinbase, Vercel, and Google's API infrastructure work.

Seltz is building web knowledge infrastructure for that same world: structured documents, real-time retrieval, designed for machine consumption from the ground up. The two products compose naturally. If you're building on Orthogonal, adding Seltz takes one line of config. If you're building directly on Seltz and want to hand your agent a pay-per-call payment rail, Orthogonal is the cleanest way to do it.

Try it today

Get $10 in free Orthogonal credits and you can call Seltz right now, no setup required.

• Try Seltz on Orthogonal

• Read Orthogonal's announcement

• Use Seltz directly— spin up an account, get $100 in free credits, grab an API key, and query the same endpoint

• Read the Seltz docs

If you're building something interesting on top of this, we'd love to hear from you. Reach out at antonio@seltz.ai — I read every message, and the team actively works with early developers to shape the roadmap.