One call.
Everything you were going to fetch anyway.

What Orbita is

There is one endpoint. You send a question in natural language; you get back the pages that answer it, ranked, with their text. The fixed modes are Fast, Standard, Pro, Deep and Ultra; mode: "auto" selects one of them without exposing a sixth candidate budget.

What makes that worth a separate product is what is not in the normal response path: no second call to fetch page content, and no separate date-extraction call. When a trustworthy publication date cannot be found, published is null rather than an invented crawl date. If you enable Context, Evidence mode still returns original blocks; Summary mode is optional and review-gated.

What it is not

Orbita is not a general chatbot, not a crawler you point at a URL, and not a Google proxy. It can optionally build a compact context or an evidence package, but it does not pretend that a generated brief is the source: Evidence mode keeps source blocks, IDs, dates and citations available for verification. If you want an essay with footnotes, ask your own model; Orbita gives it grounded material and stays out of the way.

Orbita Gravity

Gravity is Orbita’s evidence-quality technology. It reduces irrelevant page material while keeping the useful source material verifiable. Customers receive cleaner context, source links and citation-ready evidence; the internal extraction and ranking implementation is intentionally not public.

Measured outcome

Frozen 2026-09-12 run: five public Ukrainian admissions sites and ten pages. Exact-match scoring was used. This is an Orbita before/after measurement, not a head-to-head extraction benchmark.

Public competitor data

Official references checked 2026-09-13: Exa pricing and vendor evaluation; Tavily Extract and credits; Linkup pricing; Firecrawl pricing and vendor evaluation. Vendor-run quality figures are not mixed with Orbita’s measurement.

Quickstart

Three things: a key, a request, a response. If you have curl you are ninety seconds away.

1. Get a key.

   Create an account and press New key; it starts with orb_live_. It is shown in full exactly once, so copy it then. Keep it server-side — a key in a browser bundle is a key someone else is now using.

2. Put it in the environment.
   shellCopy

   export ORBITA_API_KEY="orb_live_your_key_here"

3. Make the call.
   • cURL
   • Python
   • TypeScript
   • Go

   Copy

   curl https://api.orbita.dev/v1/search \
     -H "Authorization: Bearer $ORBITA_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{
       "query": "biomimicry in contemporary architecture",
       "limit": 10,
       "content": "text"
     }'

You will get an object with results, usage and took_ms. The whole shape is in Response.

Runnable variants for cURL, Python, TypeScript and Go are kept in prototype/examples/phase2-search.*; they use the local session-token contract and do not contain production secrets.

Authentication

The public Search API uses a bearer key on every request; it does not accept signed URLs or dashboard cookies.

Authorization: Bearer orb_live_...

Keys are scoped to a project and can be rotated without downtime: create the new one, deploy it, delete the old one. A deleted key stops working immediately — there is no grace window, so do it in that order.

The dashboard itself is different: signup/signin create an opaque server session in an HttpOnly; SameSite=Strict cookie, and every state-changing browser request carries a CSRF token. Session cookies are never valid as corpus-admin credentials.

POST /v1/search

POST https://api.orbita.dev/v1/search

The only endpoint you need. It takes a question and returns ranked pages.

A full request

Every field except query has a default that is sensible on its own, so this is what a request looks like when you actually use all of it — not what you have to send.

{
  "query": "how Ukrainian grain export corridors changed in 2026",
  "mode": "auto",
  "max_mode": "deep",
  "max_cost_usd": 0.01049,
  "limit": 25,
  "content": "text",
  "max_chars": 4000,
  "lang": ["uk", "en"],
  "published_after": "2026-01-01",
  "domains": {
    "include": ["reuters.com", "pravda.com.ua"],
    "exclude": ["pinterest.com"]
  },
  "highlights": 3,
  "timeout_ms": 4000,
  "links": "relevant",
  "context": {
    "enabled": true,
    "strategy": "evidence",
    "max_tokens": 2000,
    "citations": true,
    "dates": true
  }
}

Auto + Evidence Context

Use mode: "auto" when the client should select depth. Evidence Context returns original blocks with citation IDs; Summary Context is optional and falls back to Evidence when its provider is unavailable.

curl https://api.orbita.dev/v1/search \
  -H "Authorization: Bearer $ORBITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"compare current vector database options","mode":"auto","max_mode":"deep","links":"relevant","context":{"enabled":true,"strategy":"evidence","max_tokens":1000,"citations":true,"dates":true}}'

Parameters

Response

{
  "id": "req_01JZQ8F3M2K9",
  "query": {
    "text": "how Ukrainian grain export corridors changed in 2026",
    "language": "en"
  },
  "requested_mode": "auto",
  "resolved_mode": "pro",
  "selection_reason": "multi_source_current_events",
  "results": [
    {
      "url": "https://www.reuters.com/markets/commodities/…",
      "title": "Black Sea corridor volumes recover to pre-war levels",
      "site": "reuters.com",
      "published": "2026-06-18",
      "retrieved": "2026-08-06T04:12:51Z",
      "language": "en",
      "score": 0.914,
      "text": "Grain shipments through the Black Sea corridor …",
      "highlights": [
        { "text": "volumes reached 5.2 million tonnes in May", "start": 412, "end": 454 }
      ]
    }
  ],
  "context": { "enabled": true, "strategy": "evidence", "input_tokens": 1470, "output_tokens": 1470, "max_tokens": 2000 },
  "usage": { "searches": 1, "results": 25, "context_input_tokens": 1470, "context_output_tokens": 1470, "cost_usd": 0.00799 },
  "took_ms": 138
}

Query recipes

The failure mode we see most often is a query written for a keyword engine. Choose a fixed depth when you know the budget; use Auto when the client should choose.

Errors

Every failure returns the same envelope, with the HTTP status and a stable machine-readable type. Branch on type, never on the message — messages get reworded, types do not.

{
  "error": {
    "type": "rate_limited",
    "message": "20 requests per second exceeded on key orb_live_…f31c.",
    "retry_after": 0.4,
    "retryable": true,
    "request_id": "req_01JZQ8F3M2K9",
    "docs": "https://orbita.dev/docs#errors"
  }
}

Retry that will not make things worse

import random, time, httpx

RETRYABLE = {"rate_limited", "internal", "capacity", "timeout"}

def search(payload, attempts=3):
    for attempt in range(attempts):
        r = httpx.post(URL, headers=HEADERS, json=payload, timeout=30)
        if r.status_code < 400:
            return r.json()

        err = r.json().get("error", {})
        if err.get("type") not in RETRYABLE or attempt == attempts - 1:
            raise RuntimeError(f"{err.get('type')}: {err.get('message')}")

        # Honour retry_after when the server sent one; jitter either way, or a
        # fleet of workers will retry in lockstep and rebuild the same spike.
        wait = err.get("retry_after") or 2 ** attempt
        time.sleep(wait * (0.5 + random.random()))

const RETRYABLE = new Set(["rate_limited", "internal", "capacity", "timeout"]);

async function search(payload: unknown, attempts = 3) {
  for (let attempt = 0; attempt < attempts; attempt++) {
    const res = await fetch(URL, { method: "POST", headers, body: JSON.stringify(payload) });
    if (res.ok) return res.json();

    const { error } = await res.json();
    if (!RETRYABLE.has(error.type) || attempt === attempts - 1) {
      throw new Error(`${error.type}: ${error.message}`);
    }

    // Jitter, always — otherwise every worker retries on the same tick.
    const wait = (error.retry_after ?? 2 ** attempt) * (0.5 + Math.random());
    await new Promise((r) => setTimeout(r, wait * 1000));
  }
}

Rate limits

Limits are per key, not per project, so you can give a noisy batch job its own key and keep it away from your live traffic.

Every response carries the current state, so you can pace yourself without waiting to be told off:

X-RateLimit-Limit: 20
X-RateLimit-Remaining: 17
X-RateLimit-Reset: 0.31

Pricing

Five fixed depth modes plus optional Auto. New Search is — per 1 000; Search + Compact is — and includes a controlled context pass. Page content and citation highlights are included in every mode; publication dates are included when available, and a timeout costs nothing.

Launch pricing, updated 2026-09-13. Deep is a wider single-pass retrieval budget, not a multi-step research agent. Page text and citations are included; published is nullable. Context ceilings apply to Compact output for the selected mode.

Agent quickstart

If you are a coding agent reading this page, or you are pasting context into one, this is the block to take. It is self-contained: endpoint, auth, schema, limits, and the mistakes that cost the most.

You are integrating the Orbita search API.

ENDPOINT   POST https://api.orbita.dev/v1/search
AUTH       Authorization: Bearer $ORBITA_API_KEY   (server-side only)
CONTENT    application/json

REQUEST
  query            string, required, <= 2000 chars, natural language
  mode             enum   auto | fast | standard | pro | deep | ultra, default auto
  max_mode         enum   fast | standard | pro | deep | ultra, default ultra
  max_cost_usd     number Per-request USD ceiling; same unit as usage.cost_usd
  max_results      int    1 to 100, client ceiling
  limit            int    1 to the resolved mode maximum
  content          enum   "text" | "markdown" | "none",  default "text"
  max_chars        int    200-20000, default 2000   (per result)
  lang             string[] ISO 639-1, preference not a filter
  published_after  date   YYYY-MM-DD
  published_before date   YYYY-MM-DD
  domains          { include: string[], exclude: string[] }  <= 50 each
  highlights       int    0-5, default 0
  timeout_ms       int    500-30000, default 15000
  links            enum   none | relevant | all, default relevant
  context          { enabled, strategy: summary|evidence, max_tokens, citations, dates }

RESPONSE 200
  id        string
  query     { text, language }
  results[] { url, title, site, published|null, retrieved, language,
              score, text|null, highlights[{text,start,end}] }
  context   optional { strategy, input_tokens, output_tokens, sources[] }
  links[]   discovered links; relevance-filtered by default
  coverage[] extraction coverage for returned source versions
  usage     { searches, results, context_input_tokens,
              context_output_tokens, cost_usd }
  took_ms   int

ERRORS  { error: { type, message, retryable, retry_after?, request_id, docs } }
  retryable types: rate_limited (429), internal (500), capacity (503), timeout (504)
  terminal types:  invalid_request (400), invalid_key (401), quota_exhausted (402),
                   query_too_long (413), unsupported_filter (422)
  Branch on error.type, never on error.message.
  Retry with exponential backoff AND jitter. Honour retry_after when present.

RULES THAT MATTER
  1. Write query as a question, not keywords. Semantic ranking rewards it.
  2. Do not put a year in the query to get recent pages; use published_after.
  3. Returning fewer rows does not change the selected mode price; max_chars changes downstream token cost.
  4. In a loop: content:"none" first, then re-query the two or three survivors
     with content:"text". Saves ~40ms and most of the context.
  5. published may be null. Never fabricate a date; say the source is undated.
  6. score is comparable within one response only. Do not threshold on it.
  7. Cite from highlights[].start/end, not from the model's memory of the text.
  8. A 504 is not billed. Degrading beats retrying twice for most agents.

PRICE  New Search: Fast $2.99 · Standard $4.99 · Pro $7.99 · Deep $9.99 · Ultra $13.99
       Search + Compact: $4.99 · $6.99 · $11.99 · $14.99 · $19.99
       per 1000 searches. usage.cost_usd is returned on every response.

Machine-readable sources

• /llms.txt — the index of this documentation in the llms.txt format.
• /llms-full.txt — every page as one markdown file, for pasting into a context window whole.
• /openapi.json — OpenAPI 3.1 description, for generating a client or a tool definition.

MCP server

Orbita speaks the Model Context Protocol, so Claude Code, Cursor and anything else that speaks MCP can call it without you writing a wrapper.

{
  "mcpServers": {
    "orbita": {
      "command": "npx",
      "args": ["-y", "@orbita/mcp"],
      "env": { "ORBITA_API_KEY": "orb_live_..." }
    }
  }
}

claude mcp add orbita \
  --env ORBITA_API_KEY=orb_live_... \
  -- npx -y @orbita/mcp

It exposes one tool, orbita_search, with the parameters above, including Auto, Context and links. One tool on purpose: the model picks capabilities through parameters instead of choosing among near-duplicate tools.

Claude Code can use the documented mcp.json entry; Cursor can register the same command under MCP settings; a custom MCP client should expose the same orbita_search input schema and pass the API key server-side. The local prototype includes a stdio reference server at prototype/src/mcp-server.mjs; its only search tool calls the local v1.1 API. The browser UI may also expose a separate read-only status capability, not a second search contract.

Migration map

Field by field, from whatever you are on now. Where a concept does not exist on the other side we say so instead of inventing an equivalent.

How we compare

Corrected Search100 replay

The original 100-query responses remain unchanged. The current Fast-to-Standard consistency rule is replayed over them and the original score formula is applied without manual adjustment.

Original Search100 — measured 2026-09-12

The original values remain available for auditability and are not silently rewritten after the consistency correction.

Quality = Hit@1 25% + Hit@5 20% + Hit@10 15% + MRR 20% + nDCG@10 10% + delivery 10%. All 500 calls returned successfully. *External and Orbita timings have different measurement boundaries and are not directly comparable. One AP-title Standard outlier took about four minutes and remains in the frozen record.

All known target pages were confirmed before the frozen run. Corpus size and internal index statistics are not public. Equivalent published-rate external spend: $2.00.

Historical benchmark — measured 2026-09-09

This preserved prototype run used 20 pre-registered questions, one known publisher URL per question, top ten from each provider, and no LLM judge. A hit means that exact URL appeared at or above the stated rank after URL normalisation.

Quality used one request per question/provider. Latency used six fixed sentinel queries × two clean passes, giving 12 samples per provider; all four providers had zero request errors. Orbita's p50 and p95 are prototype end-to-end measurements, not a production SLA.

Result diversity

Average number of unique domains in each top ten from the same 20-query quality run.

Unique-domain count is a diversity indicator, not a quality score. Orbita's 4.3 shows that the deliberately narrow frozen corpus repeated publishers more often than the three web-scale providers.

Vendor-published information

The figures below come from provider documentation or marketing; they are not results from the Orbita benchmark above.

Sources: Exa pricing, Exa 2.0, Tavily credits, Tavily Search API, Linkup pricing, Linkup modes, and Serper.

Hard test budget: $1.00. Estimated spend at published rates: $0.640 for completed web-provider calls, plus a conservative $0.01 Orbita reserve. The web-provider amount is an estimate, not an invoice export.

See the interactive chart on the landing page ↗

Changelog

2026-09-13

Search100, pricing and resilient intake. Published 500 first-attempt provider/mode results with confidence intervals and strata; improved corpus intake, query-body redaction, staging account/API verification and customer-facing .99 pricing. Corpus size remains private.

2026-09-12

Orbita Gravity named and documented. Published customer-visible behavior, measured outcomes and a public-capability comparison while keeping implementation details proprietary.

2026-09-09

Head-to-head benchmark replaced. Published the pre-registered exact-URL test across Orbita, Exa, Tavily and Linkup, including rank metrics, latency, date-field presence, result diversity, modes, spend and the closed-corpus limitation. Vendor-published claims are now shown separately.

2026-08-07

Accounts and keys are self-serve. Sign up with a login, an email and a password; keys are created, revealed once and revoked from the dashboard, which also carries usage, per-key spend, latency percentiles and a playground. Keys are no longer issued by hand.

2026-08-06

Documentation published. This site, plus llms.txt, llms-full.txt and an OpenAPI description.

2026-07-22

Result ceiling set at 50. Above that the marginal source stopped changing answers and only cost context.