---
title: "Search API & MCP Documentation — Orbita"
description: "Connect an AI agent to the Orbita Search API: authentication, curl examples, Fast and Standard modes, clean source text in whole paragraphs, Gravity and local MCP setup."
url: "https://orbita.surf/landing/docs.html"
---

ORBITA API / v1

# Search sources. *Inspect the evidence.*

Orbita is a source and context API built for agents rather than a general chatbot. Fast and Standard return ranked sources from the current curated index. Optional Context returns either a synthesized brief or an evidence package assembled from original source blocks.

**Search and Fetch.** Fast (1–5 results), Standard (6–10), Deep (11–25) and Auto search the index; Fetch reads any public page. Access is limited to administrators: [sign in](https://orbita.surf/landing/login.html) to create a key.

**Hosted limits — checked 14 September 2026.** These checks are not a load test or SLA. Failed requests are refunded; synchronous database work and cleanup can delay delivery of a timeout response beyond the configured deadline.

**Privacy scope.** Account usage omits query text. Hashed query caches persist; other caches live briefly in memory. Query/source blocks are sent to configured model providers. This is not end-to-end zero data retention. Legal/operator details, email recovery, paid checkout and invoice delivery remain unfinished pilot work.

[**Quickstart** Make your first API call.](https://orbita.surf/landing/docs.html#quickstart) [**Parameters** Every knob, what it costs, when to touch it.](https://orbita.surf/landing/docs.html#params) [**For AI agents** One block to paste into a coding agent.](https://orbita.surf/landing/docs.html#agents) [**Migrating** Compatibility and known differences.](https://orbita.surf/landing/docs.html#migrate)

**Private MVP.** Access is currently limited to administrators. Public launch is planned for 2027. Public registration is closed.

## What Orbita is

Orbita searches an expanding, curated index. It returns ranked sources with their clean, filtered text in whole paragraphs, source URLs and optional Context. Search does not cover the entire live web; to read a page that is not in the index, use [Fetch](https://orbita.surf/landing/docs.html#fetch-api). The current document count, topic families and the top 20 public source groups are available without authentication at `GET https://orbita.surf/v1/index/status`.

Fast returns up to 5 sources, Standard up to 10 and Deep up to 25; a deeper mode searches more widely. Auto picks one of the three for each query. Results may be fewer when the corpus does not contain enough suitable sources. Ranking scores are not probabilities of correctness.

**Hosted API.** Search is at `https://orbita.surf/v1/search` and Fetch at `https://orbita.surf/v1/fetch`. Account credit is a $1 testing grant, not a paid subscription. Production SLA, email recovery, verified-email signup and self-serve payments are not available.

### What it is not

Orbita supplies evidence for an answering model. A returned candidate still needs relevance checking. Summary output is machine-generated and may fall back to original evidence.

## 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.

**Public boundary.** We publish the behavior clients can rely on, measured outcomes and known limits. Model choices, internal stages, scoring rules, thresholds and infrastructure topology remain proprietary.

### Latest evaluation, 23–24 October 2026

200 pages from 166 sites of ten kinds: documentation, code, medicine, news in Ukrainian and English, reference, science, government, shops and others. Every one of their 71,137 blocks was labelled content or noise by a language model, and each extractor’s output was scored against those labels.

**0.97–0.98**

Gravity’s F1 on the pages’ content; 0.96–0.97 on a holdout of pages its rules were not tuned on.

**0.93**

Readability on the same pages (0.91 on the holdout); Resiliparse 0.83, trafilatura 0.83, Defuddle 0.82, Mercury 0.71, newspaper4k, jusText, BoilerPy3 and Goose3 0.43–0.67. They lose 12–73% of the content.

**0.963 / 0.879**

Gravity against Exa’s contents API on the 123 pages whose live version still matched the saved one.

**3.0%**

noise left in Gravity’s output on 150 pages.

Checks on saved HTML pages, not whole-web accuracy or production latency.

### Document formats and storage

The current ingestion path accepts HTML and PDF URLs. Programming documentation can contain HTML, CSS and JavaScript examples as source text; those examples are not executed. Direct DOCX, standalone CSS/JS file import and browser-rendered crawling are not supported by this release. PDF and image text have separate extraction and review limitations.

Search requires retained evidence passages and source metadata. Additional raw-page archives are separate and are not required for every page. Existing records remain versioned; do not assume that a website update has already removed all historical copies. Query-time requests search the available index and do not crawl arbitrary uploaded documents.

Other services’ extraction prices, checked on 21 October 2026, are in the [Fetch comparison](https://orbita.surf/landing/index.html#fetch-compare) on the landing page.

## Quickstart

Administrators can sign in, open [API keys](https://orbita.surf/landing/app.html#keys) and create a key. Public registration is closed until the planned 2027 launch. Copy its secret when it is shown: later listings only show a prefix. Store it on your server.

bash

```bash
export ORBITA_API_KEY="orb_live_your_key_here"
```

bash

```bash
curl https://orbita.surf/v1/search \
  -H "Authorization: Bearer $ORBITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"How do Cloudflare Workers and Durable Objects work together?","mode":"fast","max_results":5,"timeout_ms":30000,"links":"relevant","context":{"enabled":false}}'
```

Python (install `httpx`):

python

```python
import os, httpx
r = httpx.post("https://orbita.surf/v1/search",
    headers={"Authorization": f"Bearer {os.environ['ORBITA_API_KEY']}"},
    json={"query": "How do Cloudflare Workers and Durable Objects work together?", "mode": "fast"},
    timeout=40)
r.raise_for_status()
for hit in r.json()["results"]:
    print(hit["title"], hit["url"], hit["excerpt"])
```

JavaScript / TypeScript (Node.js with fetch):

ts

```ts
const res = await fetch("https://orbita.surf/v1/search", {
  method: "POST",
  headers: { Authorization: `Bearer ${process.env.ORBITA_API_KEY}`, "Content-Type": "application/json" },
  body: JSON.stringify({ query: "How do Cloudflare Workers and Durable Objects work together?", mode: "fast" }),
  signal: AbortSignal.timeout(40000)
});
if (!res.ok) throw new Error(`Orbita HTTP ${res.status}`);
const data = await res.json();
console.log(data.results, data.usage.cost_usd);
```

Use a client timeout above the 30-second server deadline. A successful response can contain zero results; this is billed at the selected mode's rate.

## Authentication

Server integrations send `Authorization: Bearer orb_live_…`. Keys belong to an account. Create the replacement key, update your integration, then revoke the old key. Revocation is immediate.

The browser dashboard uses an HttpOnly, Secure, SameSite=Strict session cookie. Mutating browser calls, including search, require the session-bound `X-CSRF-Token`. Dashboard sessions cannot access corpus administration.

A new account receives exactly $1 of pilot credit. Signing in again, refreshing, and creating keys do not add credit. Email ownership verification and emailed password reset are not yet implemented; this is not an unrestricted paid-service launch.

Usage events contain status, duration, result count and charge, without customer query text. Events older than 90 days are excluded from the user API and purged as new events are written. Provider processing and other data handling are described in [Privacy](https://orbita.surf/landing/privacy.html).

## POST /v1/search

`POST https://orbita.surf/v1/search`

### A full request

json

```json
{
  "query": "Compare serverless state management approaches",
  "mode": "standard",
  "max_cost_usd": 0.00599,
  "max_results": 10,
  "timeout_ms": 30000,
  "links": "relevant",
  "context": {
    "enabled": true,
    "strategy": "evidence",
    "max_tokens": 1000,
    "citations": true,
    "dates": true
  }
}
```

### Standard + Evidence Context

Context is optional and changes the price. It can return fewer tokens or no complete blocks if the evidence does not fit.

## How many results

Each mode returns a default number of results. When your agent needs a different number, it sends `max_results` inside the mode's range. The price is per search and does not change with the count.

| Mode | Default | Agent can ask for | Price per 1,000 searches |
| --- | --- | --- | --- |
| Fast | 5 | 1–5 | **$1.99** |
| Standard | 10 | 6–10 | **$3.99** |
| Deep | 25 | 11–25 | **$7.99** |
| Auto | Orbita decides | Not accepted | Price of the mode Auto picks |

Auto reads the query and picks Fast, Standard or Deep for it, with the top of that mode's range. The response's `resolved_mode` says which one ran and `max_results` how many results it returned. `max_mode` caps the depth Auto may pick, and `max_cost_usd` caps its price.

A weather question needs one or two sources, so the agent asks Fast for two:

json

```json
{
  "query": "Weather in Lviv tomorrow",
  "mode": "fast",
  "max_results": 2
}
```

Without `max_results` the mode returns its default. A count outside the mode's range returns HTTP 400 before billing, and the error names the mode to use, for example `fast returns 1–5 results; for 8 use standard (6–10)`.

## Parameters

| Field | Type / default | Behavior |
| --- | --- | --- |
| `query` | string, required | 1–1,000 characters after trimming. Searches the indexed corpus; a URL is not crawled by this endpoint. Write it in the language the pages you want are published in: the user's language for local topics (news, prices, laws, jobs), usually English for global technical documentation. Orbita does not translate; the query's language decides which language's pages rank first. |
| `mode` | fast, standard, deep or auto; default standard | Fast returns 1–5 results, Standard 6–10, Deep 11–25. Auto reads the query, picks one of the three and charges its price; `resolved_mode` says which one ran. |
| `max_mode` | fast, standard or deep; default deep | Only with Auto: the deepest mode it may pick. With any other mode it returns HTTP 400. |
| `max_results` | integer; default: the top of the mode's range | How many results to return. Each mode has its own range: Fast 1–5, Standard 6–10, Deep 11–25. The price is the same for any count in the range: ask Fast for 1–2 when one source answers (weather, an exchange rate, one fact). A count outside the mode's range returns HTTP 400 before billing and names the mode to use; the response's `max_results` shows the count used. Not accepted with Auto, which picks the count itself. `limit` is an older alias. |
| `max_cost_usd` | positive number, optional | Maximum retail charge for one request in USD. A selected mode over the ceiling is rejected before billing. |
| `timeout_ms` | integer 500–30000, default 30000 | Server deadline. Failed requests are refunded. A client-side timeout alone does not prove server work failed. |
| `links` | none, relevant, all; default relevant | Links extracted from retrieved sources. Only available links are returned. |
| `published_after` | ISO 8601 date or date-time, optional | Only pages published at or after this time, or modified when a page has no publication time. Pages without a machine-readable date are left out once a window is set. |
| `published_before` | ISO 8601 date or date-time, optional | Only pages published at or before this time. A date alone covers that whole day (UTC). |
| `full_text` | boolean, default true | False leaves the whole page (`text`) out of each result; the matched part of the page stays in `excerpt`. |
| `context.enabled` | boolean, default false | Enables the higher-priced Compact product. Source excerpts are already included without Compact. |
| `context.strategy` | evidence (default) or summary | Evidence assembles original source blocks. Summary is automated and validated; it falls back to Evidence if generation fails. |
| `context.max_tokens` | 500, 1000, 2000 or 4000; default 1000 | Context output token ceiling. Complete blocks may be withheld if they do not fit. |
| `context.citations / dates` | boolean, default true | Include source-scoped citation IDs and known dates inside Context. Unknown dates are not invented. |

**Unsupported fields are rejected.** `max_mode`, `content`, `max_chars`, `lang`, `domains` and `highlights` are not implemented in this public API. Archive and internal retrieval controls are not public options.

## Response

The following is a shape illustration, not a live result or a latency measurement:

json

```json
{
  "query": "example question",
  "mode": "fast",
  "requested_mode": "fast",
  "resolved_mode": "fast",
  "selection_reason": "explicit_mode",
  "status": "no_results",
  "results": [],
  "links": [],
  "sources": [],
  "context": {
    "enabled": false,
    "strategy": "evidence",
    "max_tokens": 1000,
    "citations": true,
    "dates": true,
    "input_tokens": 0,
    "output_tokens": 0,
    "sources": [],
    "status": "disabled"
  },
  "coverage": [],
  "usage": {
    "searches": 1,
    "results": 0,
    "context_input_tokens": 0,
    "context_output_tokens": 0,
    "cost_usd": 0.00199
  },
  "took_ms": 100,
  "ms": 100
}
```

| Field | Actual contract |
| --- | --- |
| query | The original question as a string, not a nested object. |
| results[] | Source candidates with id, url, title, source, published_at, modified_at, last_checked, version_hash, score, excerpt, text, evidence_ids and optional ranking metadata. |
| excerpt | The page's most relevant whole paragraphs, in the source's original wording. |
| text | The whole page: clean text in whole paragraphs separated by a blank line, with no length limit. There are no character-offset highlights or Markdown conversion controls. |
| published_at | Publication date when stored; may be null, empty or absent. last_checked is the retrieval check time and must not replace publication date. |
| modified_at | Last edit time the page states, or null. An article edited after publication keeps its first publication time in published_at. |
| score | Ranking value, not confidence or a globally comparable probability. No fixed 0–1 calibration is promised. |
| context | Always an object. Check enabled and status. ready, fallback and empty are distinct outcomes; sources[] contain complete original evidence blocks or validated synthesis citations. |
| usage.cost_usd | Retail charge for this request in USD, debited from the account. The value is not the underlying model-provider cost. |
| took_ms / ms | Server elapsed milliseconds. ms is a dashboard compatibility alias. |
| status | empty_index, no_results or retrieval_candidates. HTTP 200 is successful execution, not proof of a correct answer. |

## POST /v1/fetch

Fetch returns the clean text of public pages, or of a site section of up to 100 pages per request, in whole paragraphs, at **$0.50 per 1,000 pages**. It takes the same API key as search; the MCP server offers it as `orbita_fetch`.

### Read pages

json

```json
{
  "urls": [
    "https://docs.python.org/3/library/json.html",
    "https://example.com/report.pdf"
  ],
  "max_pages": 10
}
```

### Read a site section

Links are followed breadth first from the start page, on the same host and under its path.

json

```json
{
  "crawl": { "url": "https://docs.python.org/3/tutorial/" },
  "max_pages": 20
}
```

| Field | Type / default | Behavior |
| --- | --- | --- |
| `urls` | 1–20 URLs | Pages to read, each once. Send either `urls` or `crawl`. |
| `crawl.url` | URL | Start page of a crawl. |
| `crawl.same_path` | boolean, default true | Stay under the start page's path; false allows the whole host. |
| `max_pages` | 1–100, default 20 | The most pages read and billed. A PDF counts each of its pages. At least the number of `urls`. |
| `images` | boolean, default true | Read text in images and scanned PDF pages (OCR). |
| `timeout_ms` | 1000–60000, default 30000 | Server deadline. Pages read by then are returned; the rest are failed and free. |

Each result has `status` (`ok`, `failed` or `skipped`), `final_url`, `content_type` (`html` or `pdf`), `title`, `published_at`, `text` (the title, then whole paragraphs separated by a blank line), `pages` billed, `js_rendered`, `images_read` and, for a failure, `error`. `usage` gives the pages billed, the failed count and `cost_usd`.

Fetch reads only public addresses on ports 80 and 443 and respects robots.txt. A redirect to another public host is followed and checked again. A page that is empty without JavaScript is drawn in a browser where the server has one; otherwise the result says `needs_javascript`. Failed and skipped pages are not billed.

## Query recipes

**Quick lookup:** use `mode: "fast"` for up to five sources.

**Broader technical lookup:** use `mode: "standard"` for up to ten sources. Add Context Evidence when you need a bounded evidence package.

**Need a short synthesis:** enable Context Summary. Always check `context.status`; fallback means original evidence was returned instead of a generated brief.

**Need date or domain filters:** filter returned results in your application for now. That does not guarantee exhaustive filtered recall.

## Errors

After an unexpected process restart, unfinished search reservations are refunded after a two-minute grace period, checked every minute. A confirmed completed charge is never refunded by this recovery.

Branch on the HTTP status. The error body currently contains a string; nested `error.type`, `retry_after` and request IDs are not part of this contract.

json

```json
{"error":"Selected mode exceeds max_cost_usd","message":"Selected mode exceeds max_cost_usd"}
```

| HTTP | Meaning |
| --- | --- |
| 400 | Invalid input, unsupported parameters or budget ceiling exceeded. |
| 401 | Missing, invalid or revoked credentials. |
| 402 | Insufficient account credit. |
| 403 | Invalid CSRF, origin, host or forbidden access. |
| 404 | Unknown route or an unavailable private surface. |
| 409 | Idempotency key already used, conflicting account data or source changes during retrieval. |
| 413 / 415 | Body too large / JSON Content-Type required. |
| 422 | Required account or legal-acceptance fields are invalid. |
| 429 | Per-account concurrency/rate or shared capacity limit. |
| 500 / 504 | Upstream/runtime failure or server deadline; search reservation refunded. |

### Retry that will not make things worse

Send a unique `Idempotency-Key` for each new search. Reusing it returns 409 and cannot charge twice; response replay is not provided. If the client lost the response, do not automatically use a new key: the original request may have succeeded. Check account usage. For a confirmed 429, back off with jitter; no Retry-After header is currently promised.

## Rate limits

Current pilot limits: **60 searches per minute per account**, **2 in-flight searches per account**. All keys on one account share the limit. Limits are approximate and are not separate commercial plan tiers.

The request body ceiling is 32 KiB and the server search deadline is at most 30 seconds. X-RateLimit headers are not implemented.

## Pricing

Prices are USD per 1,000 successful searches. The $1 pilot grant is consumed per request. A successful empty result is billed; a failed search is refunded. Cached successful searches still have the same retail charge. Compact fallback retains the Compact price.

| Mode | Results | Search | Search + Compact |
| --- | --- | --- | --- |
| Fast | 1–5 | $1.99 | $2.99 |
| Standard | 6–10 | $3.99 | $5.99 |
| Deep | 11–25 | $7.99 | $12.99 |
| Auto | Resolves to Fast, Standard or Deep | Resolved price | Resolved price |

Fast costs `$0.00199` per call: a $1 balance becomes `$0.99801`. Standard costs `$0.00399`. Deep costs `$0.00799`. Fast + Compact costs `$0.00299`; Standard + Compact costs `$0.00599`; Deep + Compact costs `$0.01299`. The price is the same for any result count inside the mode's range. The authoritative source is [pricing.json](https://orbita.surf/landing/pricing.json) and `GET /v1/pricing`; inspect each row's `available` flag.

### Fetch

Fetch returns clean text from any URL or a site section of up to 100 pages per request, in whole paragraphs: JavaScript is rendered when a page needs it, every PDF page is read and text in images is read with OCR. It costs **$0.50 per 1,000 pages**, the same for a single URL or a crawled page; failed pages are free and robots.txt is respected. A request holds `max_pages` from the balance and is charged only for the pages read. The price is in [pricing.json](https://orbita.surf/landing/pricing.json) under `fetch`.

Output Context is separately capped at 500, 1,000, 2,000 or 4,000 tokens. Payments, automatic top-ups and invoices are not enabled for this pilot.

## Agent quickstart

Read [the machine-readable contract](https://orbita.surf/landing/llms-full.txt) and [OpenAPI](https://orbita.surf/landing/openapi.json). Call the HTTPS endpoint from a server with an account API key. Start with a small query and check status, available sources and charged cost.

bash

```bash
curl https://orbita.surf/v1/search \
  -H "Authorization: Bearer $ORBITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"How do Cloudflare Workers and Durable Objects work together?","mode":"fast","max_results":5,"timeout_ms":30000,"links":"relevant","context":{"enabled":false}}'
```

### Machine-readable sources

[OpenAPI](https://orbita.surf/landing/openapi.json) · [llms.txt](https://orbita.surf/landing/llms.txt) · [llms-full.txt](https://orbita.surf/landing/llms-full.txt) · [MCP manifest](https://orbita.surf/mcp.json).

## MCP server

Connect an MCP client to your Orbita account with the `orbita_search` and `orbita_fetch` tools. They use the same API key, credit and limits as the API. The server runs locally over **stdio**; there is no hosted MCP/SSE URL.

1. [Create an API key](https://orbita.surf/landing/app.html#keys) and save the secret.
2. Install Node.js 24 or later, then [download the standalone MCP server](https://orbita.surf/landing/orbita-mcp.mjs). The file includes its dependencies; no repository access or npm installation is required.
3. Add the configuration below to your client's MCP settings. Replace the script path and key, then restart or reconnect the client.

```json
{
  "mcpServers": {
    "orbita": {
      "command": "node",
      "args": ["/absolute/path/to/orbita-mcp.mjs"],
      "env": {
        "ORBITA_API_URL": "https://orbita.surf",
        "ORBITA_API_KEY": "REPLACE_WITH_YOUR_ORBITA_KEY"
      }
    }
  }
}
```

The JSON format works in clients with a `mcpServers` settings object; other clients may ask for the command, arguments and environment separately. Store the real key in private client settings, never in a shared repository or URL.

### Verify the connection

The client should list `orbita_search` and `orbita_fetch`. Ask it to search with `mode: fast`; an executed search consumes account credit. A successful result contains source URLs, their page text and `usage.cost_usd`. Check [Usage](https://orbita.surf/landing/app.html#usage) and the key's last-used time afterward. Tool discovery alone does not verify the API key or search provider.

**Troubleshooting.** No tool: check the absolute script path and Node version. HTTP 401: check the full key, not its prefix, and whether it was revoked. HTTP 402: check account credit. HTTP 429: wait and retry. Other API errors: check service availability; failed executed searches are refunded. The server negotiates MCP protocol `2025-06-18`.

For repository development, the same implementation is available at `prototype/src/mcp-server.mjs` after installing the locked dependencies. `npm run build:mcp` regenerates the standalone download.

## Migration map

This API is not a drop-in replacement for other providers. Map your question to `query`, your result count to `max_results` and choose an Orbita mode explicitly. Adapt response parsing to `excerpt`, `published_at` and `evidence_ids`.

Provider-specific live-web, domain/date filtering, full-page content and answer-generation options have no direct equivalent here. Unsupported request fields return HTTP 400. Evaluate the same real tasks against a frozen, representative corpus before migrating.

## Availability

Fast (1–5 results), Standard (6–10), Deep (11–25), Auto and Fetch ($0.50 per 1,000 pages) all work. Access is limited to administrators until the public launch planned for 2027. Detailed internal benchmark and system reports are not public.

## Changelog

**2026-10-22**

**Deep, Auto and Fetch open.** `mode` takes `deep` (11–25 results) and `auto`, which reads the query, picks Fast, Standard or Deep and charges that mode's price; `max_mode` caps it. `POST /v1/fetch` reads public pages or a site section at $0.50 per 1,000 pages, and the MCP server adds `orbita_fetch`. Access stays with administrators.

**2026-09-14**

**Gravity 2.0.** Documented improved evidence preservation, separate development regression/replay results, format limitations and ongoing corpus reprocessing.

**2026-09-13**

**Search100, pricing and resilient intake.** Historical provider/mode verification, improved corpus intake, query-body redaction, account/API checks and customer-facing .99 pricing. Detailed reports remain private; current aggregate corpus counts are available through [index status](https://orbita.surf/v1/index/status).

**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.** Administrator accounts are provisioned privately; 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.

SEARCH API / COMMON QUESTIONS

## Before you connect an agent.

### Does Orbita search the whole web?

No. Orbita searches a curated, expanding index of public sources. Results depend on that coverage. A missing result does not prove that the information is absent from the web; test the sources your agent actually needs.

### What does an agent get back?

A ranked list of source titles, URLs and the clean original text of the matching passages, in whole paragraphs. The API also provides freshness and version metadata when available. Gravity cleans source material while retaining content such as code, tables and mathematical notation; it does not certify that an agent's answer is correct.

### How do I use Orbita with MCP?

Run the local stdio MCP server and give it an Orbita API key. It calls the hosted Search API over HTTPS. Follow the [MCP setup](https://orbita.surf/landing/docs.html#mcp) for the Node.js requirement and configuration; a hosted HTTP or SSE MCP endpoint is not currently provided.

### How should I compare search APIs?

Use the same real tasks, result budgets and content requirements. Check relevant source coverage, excerpt usefulness, input tokens, successful delivery and latency separately. The [benchmark of 24 October 2026](https://orbita.surf/landing/benchmarks.html) documents its method and limits; it is not a guarantee for new queries.

[← Back to orbita.surf](https://orbita.surf/landing/index.html) ORBITA / 2026 [Legal & trust](https://orbita.surf/landing/legal.html) · [Privacy](https://orbita.surf/landing/privacy.html) · [Terms](https://orbita.surf/landing/terms.html) · [llms.txt](https://orbita.surf/landing/llms.txt)

---

[← Back to orbita.surf](https://orbita.surf/landing/index.html) ORBITA / 2026 [Legal & trust](https://orbita.surf/landing/legal.html) · [Privacy](https://orbita.surf/landing/privacy.html) · [Terms](https://orbita.surf/landing/terms.html) · [llms.txt](https://orbita.surf/landing/llms.txt)