> ## Documentation Index
> Fetch the complete documentation index at: https://docs.seltz.ai/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Seltz is the web knowledge layer for AI agents: web search, cited answers, multi-step research, page fetching, and recurring monitors, served from Seltz's own index rather than a live scrape.
> Use Seltz when a task needs current, citable, public web content, not when your own knowledge already answers it confidently. Seltz has no access to a caller's private or authenticated data.
> Choose which endpoint to use according to the job: Use Answer for one synthesized, cited response; Use Search for the raw documents to reason over yourself; Use Agent for in-depth research needing several rounds of searching and following up, not a single lookup; Use Fetch when you already have a URL and just need its content, not a search; Use Monitor for an ongoing feed of what's new, not a one-off query or near-real-time alerting.
> When you use Search, Answer, or Monitor, set a `scope` that matches the query. `web` (beta) is the default and covers general queries. Only these three endpoints take a scope. See https://docs.seltz.ai/data/data-concepts#scopes for the full list of scopes and what each one covers.
> For the REST API, send your API key in the `x-api-key` header. The Python and JavaScript SDKs read the `SELTZ_API_KEY` environment variable and handle authentication for you. To use Seltz as MCP tools, connect `https://mcp.seltz.ai/mcp`.
> The OpenAPI 3.1 spec for the REST API is at https://docs.seltz.ai/api-reference/openapi.json. Point function-calling or client-generation tooling at that file.
> Use `/llms-full.txt` for the full text of every page.

# MCP

> Connect Seltz to Claude Code, VS Code, Codex, Cursor, Antigravity, and other MCP clients

The Seltz MCP server gives AI assistants and coding agents live web search and page fetching through Seltz. Seltz hosts the server at `https://mcp.seltz.ai/mcp`, so you have nothing to install or update. You need a Seltz account, which you can create in the [Console](https://console.seltz.ai/). Your client opens the Console so you can sign in when it connects. You only need an API key if your client can't sign in.

> [!NOTE]
>
> **Already connected?** Connections you made with an API key keep working. To switch to Console sign-in, remove the server and add it again. If a tool call fails with an unknown argument name, refresh or reconnect the server. See the [November 2026 changelog](https://docs.seltz.ai/changelog/2026-11-mcp-server-update.md) for what changed.

## Install

Pick your client below. If you don't see it, the **Other clients** tab has the settings any MCP client needs.

> [tab] Claude Code
>
> Add the server:
>
> ```bash theme={null}
> claude mcp add --transport http seltz https://mcp.seltz.ai/mcp
> ```
>
> Then run `/mcp` in Claude Code, select **seltz**, and authenticate. Sign in to the Seltz Console in the browser that opens, then click **Allow**.

> [tab] VS Code
>
> > [card] [Add to VS Code](vscode:mcp/install?%7B%22name%22%3A%20%22seltz%22%2C%20%22url%22%3A%20%22https%3A//mcp.seltz.ai/mcp%22%7D)
> >
> > Install the Seltz MCP server in VS Code
>
> VS Code installs the server, starts it, and opens the Seltz Console. Sign in and click **Allow**.
>
> Or add the server to `.vscode/mcp.json` yourself:
>
> ```json .vscode/mcp.json theme={null}
> {
>   "servers": {
>     "seltz": {
>       "type": "http",
>       "url": "https://mcp.seltz.ai/mcp"
>     }
>   }
> }
> ```
>
> To send an API key instead, add a `headers` block with `"Authorization": "Bearer YOUR_API_KEY"` inside `seltz`.
>
> VS Code doesn't start a server you add this way by itself. Open the Command Palette, run **MCP: List Servers**, select **seltz**, and choose **Start Server**.

> [tab] Codex
>
> Add the server:
>
> ```bash theme={null}
> codex mcp add seltz --url https://mcp.seltz.ai/mcp
> ```
>
> Codex starts authorization right away. In the Seltz Console page that opens, sign in and click **Allow**. If you close the page before you finish, run `codex mcp login seltz` to start again.
>
> To send your API key instead, store it in the `SELTZ_API_KEY` environment variable and add the server with:
>
> ```bash theme={null}
> codex mcp add seltz --url https://mcp.seltz.ai/mcp --bearer-token-env-var SELTZ_API_KEY
> ```

> [tab] Cursor
>
> > [card] [Add to Cursor](cursor://anysphere.cursor-deeplink/mcp/install?name=seltz\&config=eyJ1cmwiOiJodHRwczovL21jcC5zZWx0ei5haS9tY3AifQ%3D%3D)
> >
> > Install the Seltz MCP server in Cursor
>
> After it installs, click **Authorize** in Cursor. In the Seltz Console page that opens, sign in and click **Allow**.
>
> Or add the server to `.cursor/mcp.json` yourself:
>
> ```json .cursor/mcp.json theme={null}
> {
>   "mcpServers": {
>     "seltz": {
>       "url": "https://mcp.seltz.ai/mcp"
>     }
>   }
> }
> ```
>
> To send an API key instead, add a `headers` block with `"Authorization": "Bearer YOUR_API_KEY"` inside `seltz`.

> [tab] Antigravity
>
> Install the Seltz plugin:
>
> ```bash theme={null}
> agy plugin install https://github.com/seltz-ai/seltz-antigravity-plugin
> ```
>
> Then sign in to the Seltz Console in the browser that opens, and click **Allow**.
>
> Or add the server to Antigravity yourself. Open the **⋮** menu in the agent panel, select **MCP Servers**, then **Manage MCP Servers**, and click **View Raw Config**. Add the server to the file that opens, `~/.gemini/config/mcp_config.json`:
>
> ```json ~/.gemini/config/mcp_config.json theme={null}
> {
>   "mcpServers": {
>     "seltz": {
>       "serverUrl": "https://mcp.seltz.ai/mcp"
>     }
>   }
> }
> ```
>
> Antigravity names the URL `serverUrl`, not `url`. When you save the file, Seltz appears in **Manage MCP Servers**. Click **Authenticate**, sign in to the Seltz Console, and click **Allow**.
>
> To send an API key instead, add a `headers` block with `"Authorization": "Bearer YOUR_API_KEY"` inside `seltz`. With a key in the header, you can ignore the **Authenticate** button.

> [tab] Other clients
>
> Any client that supports remote MCP servers can connect with these settings:
>
> | Setting | Value |
> | - | - |
> | URL | `https://mcp.seltz.ai/mcp` |
> | Transport | Streamable HTTP |
> | Sign in | Seltz Console, through OAuth 2.1 with PKCE, client ID metadata documents, and dynamic client registration |
> | API key (optional) | Header `Authorization: Bearer YOUR_API_KEY` or `x-api-key: YOUR_API_KEY` |
>
> Most clients read the server from an `mcpServers` block in their config file. A client that supports MCP sign-in opens the Seltz Console when it connects:
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "seltz": {
>       "url": "https://mcp.seltz.ai/mcp"
>     }
>   }
> }
> ```
>
> A client without MCP sign-in needs a `headers` block with your API key inside `seltz`:
>
> ```json theme={null}
> "headers": {
>   "Authorization": "Bearer YOUR_API_KEY"
> }
> ```
>
> Where that file lives, and the name of the block, varies by client. Here's how two common clients take it.
>
> **Gemini CLI** reads the block above from `~/.gemini/settings.json`. It only runs MCP servers in folders you trust, so in a folder you haven't trusted, `gemini mcp list` shows Seltz as **Disabled**. Trust the folder in Gemini CLI, then run `gemini mcp list` again to check that Seltz shows as **Connected**.
>
> **OpenCode** reads servers from an `mcp` block in `opencode.json`, and a hosted server needs `"type": "remote"`:
>
> ```json opencode.json theme={null}
> {
>   "$schema": "https://opencode.ai/config.json",
>   "mcp": {
>     "seltz": {
>       "type": "remote",
>       "url": "https://mcp.seltz.ai/mcp",
>       "headers": {
>         "Authorization": "Bearer YOUR_API_KEY"
>       }
>     }
>   }
> }
> ```
>
> Run `opencode mcp list` to check that Seltz shows as connected.

## Claude Desktop and claude.ai

Claude's desktop and web apps connect through the Seltz connector in Claude's connector directory.

1. In Claude, open **Customize** from the menu in the left panel, then go to **Connectors**. On claude.ai, you can go straight to [Customize → Connectors](https://claude.ai/customize/connectors).
2. On the **Discover** tab, search for **Seltz** and click **Connect**.
3. In the Seltz Console page that opens, sign in, choose your organization if you belong to more than one, and click **Allow**.

Once connected, Seltz is also available in Cowork.

If Seltz doesn't appear in your directory, add it as a custom connector instead:

> [card] [Add to Claude](https://claude.ai/customize/connectors?modal=add-custom-connector)
>
> Name it `Seltz` and set the remote MCP server URL to `https://mcp.seltz.ai/mcp`

Then click **Connect** and sign in, as above.

> [!NOTE]
>
> Claude connectors require a paid Claude plan (Pro, Max, Team, or Enterprise).

### Clients that only run local servers

Some clients can only launch MCP servers as local processes, as Claude Desktop does for servers in its `claude_desktop_config.json` file. The [`mcp-remote`](https://www.npmjs.com/package/mcp-remote) package bridges them to the hosted server. It needs Node.js.

```json theme={null}
{
  "mcpServers": {
    "seltz": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.seltz.ai/mcp"]
    }
  }
}
```

With this config, `mcp-remote` opens the Seltz Console sign-in in your browser the first time it connects. To send your API key directly instead, pass it as a header. The key goes in `env` because some clients on Windows split arguments that contain spaces:

```json theme={null}
{
  "mcpServers": {
    "seltz": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.seltz.ai/mcp", "--header", "Authorization:${AUTH_HEADER}"],
      "env": {
        "AUTH_HEADER": "Bearer YOUR_API_KEY"
      }
    }
  }
}
```

## Authentication

Every request to the server bills one Seltz organization. Clients connect in one of two ways:

| Method | How it works | Use it for |
| - | - | - |
| Sign in with the Console | The client opens the [Seltz Console](https://console.seltz.ai/). You sign in with Google or email, choose an organization if you belong to more than one, and click **Allow** on a consent page that shows the organization and what the app can do. The server supports OAuth 2.1 with PKCE, client ID metadata documents (how Claude and Claude Code identify themselves), and dynamic client registration. The consent page marks an app that registers itself as **Unverified**. | Claude Code, Codex, the Claude connector, the one-click Cursor and VS Code installs, and any client that supports MCP authorization |
| API key header | The client sends your key with every request, either as `Bearer YOUR_API_KEY` in the `Authorization` header or in the `x-api-key` header. | Clients without MCP authorization, server-side agents, and config files you manage yourself |

With sign-in, Seltz bills the organization you pick and attributes the calls to you. With an API key header, Seltz bills the key's organization. Either way, calls cost the same as the matching [Search](https://docs.seltz.ai/pricing.md#search) and [Fetch](https://docs.seltz.ai/pricing.md#fetch) API calls.

> [!WARNING]
>
> A config file with `YOUR_API_KEY` filled in holds a live credential. Keep project-level files such as `.cursor/mcp.json` and `.vscode/mcp.json` out of version control once they contain your key, or sign in through the Console instead.

### Manage connected apps

[Connected apps](https://console.seltz.ai/connected-apps) in the Console lists the apps you've allowed, per organization. You can remove one app or disconnect them all.

Organization admins also see members' connections on the **Organization** tab. They can remove a member's apps, or block the member from connecting until they lift the block.

Seltz refuses calls from a removed or blocked connection right away, and the client asks you to sign in again.

## Tools

The server exposes two tools. Your client reads their full schemas from the server, so the agent knows how to call them. Both tools return Markdown for an agent to read.

| Tool | What it does |
| - | - |
| `search` | Searches the web in real time and returns each result's URL, its publication date when known, its [snippets](https://docs.seltz.ai/search/guides/get-snippets.md), and its [properties](https://docs.seltz.ai/search/guides/get-structured-properties.md). Results carry no page text, so call `fetch` on a result's URL for the full page. |
| `fetch` | Returns the full content of 1 to 5 web pages as Markdown, with navigation, footers, and ads removed. |

`search` takes a required `query`, plus these optional arguments:

| Argument | What it does |
| - | - |
| [`max_results`](https://docs.seltz.ai/search/guides/limit-results) | The most results to return. Defaults to 10. The server lowers a higher value to 50. |
| [`scope`](https://docs.seltz.ai/data/data-concepts#scopes) | The kind of information the query is after: `web`, `news`, `companies`, `people`, `financial-reports`, or `wikipedia`. Seltz uses it to route and rank results. Leave it unset for general queries. [`companies`](https://docs.seltz.ai/data/companies) and [`people`](https://docs.seltz.ai/data/people) have no publication dates, so `from_date` and `to_date` fail with them. |
| `include_domains`, `exclude_domains` | Lists of up to 100 domains each, to restrict results to or leave out. |
| [`from_date`, `to_date`](https://docs.seltz.ai/search/filter-by-date) | Limit results by publication date, in UTC. Each takes a date (`2025-10-28`), a datetime (`2025-10-28T23:00:00Z`), or an offset from now such as `now-7d`. A date in `to_date` covers that whole day. When you set either filter, the server drops results with no publication date. |

`fetch` takes `urls`, a list of 1 to 5 absolute URLs, and rejects duplicates. It reads HTML and plain-text pages, and returns `unsupported_content_type` for PDFs, images, and other binaries. One call returns at most 100,000 characters of page text, split equally among the pages, and the server cuts a longer page and notes its full length. It returns one result per URL, either `ok` with the page as Markdown or `error` with a code such as `url_not_accessible` or `timeout`, and one URL failing doesn't affect the others. See [Fetch](https://docs.seltz.ai/fetch/concepts.md) for more on how it reads pages.

> [!NOTE]
>
> **Parsing results in code?** Use the REST API instead. The MCP server writes its output for agents to read, and its wording can change. The [Search](https://docs.seltz.ai/search/guides/basic-search.md) and [Fetch](https://docs.seltz.ai/fetch/quickstart.md) endpoints return JSON described by the [OpenAPI spec](https://docs.seltz.ai/api-reference/openapi-spec.md), take the same argument names, and accept an API key from the Console.

## Troubleshooting

> [accordion] Sign-in shows "MCP access is blocked"
>
> An organization admin blocked you from connecting. Ask them to lift the block under **Connected apps → Organization** in the Console.

> [accordion] Tool calls say "The Seltz API refused the request. Reconnect the Seltz server"
>
> This message has two causes:
>
> * **Someone removed the app under Connected apps.** Reconnect the server and sign in again. In Claude Code, run `/mcp`, select the server, and authenticate.
> * **Your organization is out of credit.** Reconnecting won't fix this. Add credit under **Billing** in the [Console](https://console.seltz.ai/), then try the call again.

> [accordion] Tool calls fail with "Invalid, expired, or revoked API key"
>
> This applies to clients that connect with an API key header. The client connected, but Seltz rejected the key when a tool ran. Check the key in the [Console](https://console.seltz.ai/), and make sure the header reads `Bearer YOUR_API_KEY` with a space after `Bearer`.

> [accordion] A tool call fails with an unknown argument name
>
> `search` takes snake\_case names such as `max_results` and `from_date`, the same as the REST API. A call with an old camelCase name such as `maxResults` fails, and the error lists the names the tool accepts. If your client keeps a saved copy of the tool list, such as a ChatGPT connector, refresh or reconnect the server.

> [accordion] The client doesn't list the Seltz server
>
> Check the config file for JSON syntax errors, then restart the client or reload its MCP servers. Clients also name the URL field differently: Antigravity expects `serverUrl`, and VS Code expects a `servers` block with `"type": "http"`. If your client can only launch local servers, use [`mcp-remote`](#clients-that-only-run-local-servers).

> [accordion] mcp-remote fails to start
>
> `mcp-remote` runs through `npx`, so the client needs Node.js on its `PATH`. Run `npx -y mcp-remote https://mcp.seltz.ai/mcp` in a terminal to see the error directly.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.