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

> ## Agent Instructions
> Every page is listed in https://docs.keenable.ai/llms.txt. To pick a product for a job, read https://docs.keenable.ai/choose.md
> Setup steps for agents, covering the SDKs, the MCP server and the CLI: https://docs.keenable.ai/skill.md
> Keenable search and fetch work without an API key. To add them to code, use the official SDK for the project's language: https://docs.keenable.ai/sdks.md
> Without a key, call POST https://api.keenable.ai/v1/search/public or GET https://api.keenable.ai/v1/fetch/public with an X-Keenable-Title header that names your app.
> With a key, send it in the X-API-Key header and read it from the KEENABLE_API_KEY environment variable. Never ask a user to paste a key into chat. Every access method: https://docs.keenable.ai/auth.md
> To get an API key without the console, use device login: https://docs.keenable.ai/authentication.md#device-login
> MCP server: https://api.keenable.ai/mcp (no key, or X-API-Key; keyless Codex uses https://api.keenable.ai/mcp-public), or https://api.keenable.ai/mcp-oauth for OAuth sign-in. These docs are an MCP server at https://docs.keenable.ai/mcp and the OpenAPI spec is at https://docs.keenable.ai/api-reference/openapi.json
> Keenable searches and fetches public web pages. If a question needs no web information, skip the call.
> On 402 with an API key (code insufficient_credits), stop and ask a human to add credits; don't retry. On 429, wait the number of seconds in Retry-After, then retry. Before you ship, follow https://docs.keenable.ai/production.md
> Every error, with its cause and fix, is in https://docs.keenable.ai/errors.md and moving from another search API is covered in https://docs.keenable.ai/migrate.md
> Before you compare Keenable with another search API, read https://docs.keenable.ai/guides/evaluate-search-apis.md

# Use Keenable search and fetch without an API key

> How to call search and fetch with no API key: the /public paths, the X-Keenable-Title header, /mcp-public, and the 1,000 per hour keyless limit per IP.

Let your agent search and fetch the web before anyone creates an account. Call the `/public` paths and name your app in the `X-Keenable-Title` header. Keyless calls are free, and Keenable limits them per IP address: 1,000 requests per hour and 10 per second, for each endpoint.

## Parameters

The public paths take the same body and query parameters as the keyed ones, plus your app's name:

| Parameter | In | Type | Default | Limits | What it does |
| - | - | - | - | - | - |
| `X-Keenable-Title` | Header, `/v1/search/public` | string | Required | At most 256 characters | Name of the application making the call. The public endpoints need it, here or in the `keenable_title` query parameter; without either, the API returns `400` with `Missing app identifier`. Values over 256 characters are truncated. |
| `keenable_title` | Query, `/v1/search/public` | string | None | At most 256 characters | Same as the `X-Keenable-Title` header, for clients that can't set headers. The header wins if you send both. |
| `X-Keenable-Session-Id` | Header, `/v1/search/public` | string | None | At most 128 characters | Your own ID for grouping related requests. You can send it as the `session_id` parameter instead; the header wins if you send both. |

`GET /v1/fetch/public` takes the same headers and the `keenable_title` query parameter.

## Keyless paths

| Keyed path | Keyless path |
| - | - |
| `POST https://api.keenable.ai/v1/search` | `POST https://api.keenable.ai/v1/search/public` |
| `GET https://api.keenable.ai/v1/fetch` | `GET https://api.keenable.ai/v1/fetch/public` |
| `https://api.keenable.ai/mcp` with an `X-API-Key` header | `https://api.keenable.ai/mcp`, or `https://api.keenable.ai/mcp-public` for presets and listings |

## Search without a key

This sample creates a client with no API key and your app's name, confirms it runs keyless, and prints the top 3 results. With no key, each SDK calls the `/public` paths and sends its client source as `X-Keenable-Title`:

```typescript TypeScript theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
import { Keenable } from "keenable";

async function main() {
  // No API key: the client calls /v1/search/public and /v1/fetch/public.
  // clientSource is sent as the X-Keenable-Title header.
  const client = new Keenable({ clientSource: "Acme research agent" });
  console.log("keyless:", client.keyless);

  const results = await client.search("OWASP guidance on storing API keys in a backend service", {
    maxResults: 3,
  });
  for (const result of results) console.log(result.title, result.url);
}

main();
```

```python Python theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
from keenable import Keenable

# No API key: the client calls /v1/search/public and /v1/fetch/public.
# client_source is sent as the X-Keenable-Title header.
client = Keenable(client_source="Acme research agent")
print("keyless:", client.keyless)

results = client.search("OWASP guidance on storing API keys in a backend service", max_results=3)
for result in results:
    print(result.title, result.url)
```

```go Go theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/keenableai/keenable-sdk/go"
)

func main() {
	// No API key: the client calls /v1/search/public and /v1/fetch/public.
	// ClientSource is sent as the X-Keenable-Title header.
	client, err := keenable.New(&keenable.Options{ClientSource: "Acme research agent"})
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()
	fmt.Println("keyless:", client.Keyless())

	results, err := client.Search(context.Background(),
		"OWASP guidance on storing API keys in a backend service",
		&keenable.SearchOptions{MaxResults: 3})
	if err != nil {
		log.Fatal(err)
	}
	for _, result := range results.Results {
		fmt.Println(result.Title, result.URL)
	}
}
```

```rust Rust theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
use keenable::{Client, Options, SearchOptions};

#[tokio::main]
async fn main() -> Result<(), keenable::Error> {
    // No API key: the client calls /v1/search/public and /v1/fetch/public.
    // client_source is sent as the X-Keenable-Title header.
    let client = Client::with_options(Options {
        client_source: Some("Acme research agent".into()),
        ..Default::default()
    })?;
    println!("keyless: {}", client.is_keyless());

    let results = client
        .search_with(
            "OWASP guidance on storing API keys in a backend service",
            &SearchOptions {
                max_results: Some(3),
                ..Default::default()
            },
        )
        .await?;
    for result in &results {
        println!("{} {}", result.title, result.url);
    }
    Ok(())
}
```

```bash curl theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
# No X-API-Key header: call the /public path and name your app instead
curl -X POST https://api.keenable.ai/v1/search/public \
  -H "Content-Type: application/json" \
  -H "X-Keenable-Title: Acme research agent" \
  -d '{
    "query": "OWASP guidance on storing API keys in a backend service",
    "max_results": 3
  }'
```

You see `keyless: True` (`true` in TypeScript, Go and Rust), then one line per result:

```text Example output · results vary theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
keyless: True
DevSecOpsGuideline/current-version/2-Process/2-2-Develop/2-2-1-Pre-commit/2-2-1-2-Secrets-Management.md at master · OWASP/DevSecOpsGuideline https://github.com/OWASP/DevSecOpsGuideline/blob/master/current-version/2-Process/2-2-Develop/2-2-1-Pre-commit/2-2-1-2-Secrets-Management.md
How to safely store API Keys in a database for a REST API? https://stackoverflow.com/questions/78580774/how-to-safely-store-api-keys-in-a-database-for-a-rest-api
MASWE-0005: API Keys Hardcoded in the App Package https://mas.owasp.org/MASWE/MASVS-AUTH/MASWE-0005
```

If `KEENABLE_API_KEY` is set in the environment, the SDKs use it and call the keyed paths instead. If you leave the client source out, the SDKs send `Keenable SDK`.

## Read the response and the limit headers

A keyless response has the same shape as a keyed one, without the `usage` object. Each response also carries the hourly limit for your IP address. This is the curl request with `max_results` set to 1 and `snippet_max_length` to 180:

```text Response · results vary theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
x-ratelimit-limit: 1000
x-ratelimit-remaining: 947
x-ratelimit-reset: 2026-11-19T12:36:32.384Z

{"query":"OWASP guidance on storing API keys in a backend service","mode":"pro","results":[{"title":"DevSecOpsGuideline/current-version/2-Process/2-2-Develop/2-2-1-Pre-commit/2-2-1-2-Secrets-Management.md at master · OWASP/DevSecOpsGuideline","url":"https://github.com/OWASP/DevSecOpsGuideline/blob/master/current-version/2-Process/2-2-Develop/2-2-1-Pre-commit/2-2-1-2-Secrets-Management.md","description":"","snippet":"with access controls and audit logs.\n- Applications retrieve secrets at runtime via API, not at build time.\n- Access is controlled by identity (IAM role, service account,","acquired_at":"2026-11-15T21:27:35Z"}]}
```

If you leave out `X-Keenable-Title`, the API returns `400`:

```json Response theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
{
  "error": "Missing app identifier",
  "message": "X-Keenable-Title header is required for token-less requests",
  "type": "invalid_request_error",
  "code": "missing_app_title",
  "fix": "Name your app in the X-Keenable-Title header (or the keenable_title query parameter) and retry. With an API key, call /v1/search or /v1/fetch instead, which do not need it.",
  "docs_url": "https://docs.keenable.ai/errors#missing-app-title",
  "retryable": false,
  "param": "X-Keenable-Title"
}
```

## Keyless limits

| Limit | Value |
| - | - |
| Requests per hour, per IP address, for each endpoint | 1,000 |
| Requests per second, per IP address, for each endpoint | 10 |
| Cost | Free |

You share the per-IP pool with all other traffic from your IP address, such as other people behind the same office network. Over a limit, the API returns `429` with `Retry-After`, and the body's `code` is `public_rate_limit_per_second` or `public_rate_limit_hourly`. An hourly `429` keeps coming back until the time in `limit.resets_at`. See [Rate limits](https://docs.keenable.ai/rate-limits.md#when-you-hit-a-limit).

An [API key](https://docs.keenable.ai/api-keys.md) replaces the per-IP limit with your organization's own limit, 10 requests per second with no hourly cap, and adds the `usage` object to each response. [Monitors](https://docs.keenable.ai/products/monitors) needs a key.

## Keyless MCP

Point an MCP client at `https://api.keenable.ai/mcp` with no key and it runs on the keyless tier. If you ship Keenable in a preset, a catalog entry or a docs example, use `https://api.keenable.ai/mcp-public` instead. It is the same server with the same tools, but it publishes no OAuth discovery metadata, so clients connect without offering a sign-in. On `/mcp-public`, `search_web_pages` doesn't offer `mode`. See [Keyless endpoint for listings and presets](https://docs.keenable.ai/mcp-server.md#keyless-endpoint-for-listings-and-presets).

## Common mistakes

| Wrong | Right | Why |
| - | - | - |
| `POST /v1/search` with no key | `POST /v1/search/public` with `X-Keenable-Title` | The keyed path returns `401` with `missing_api_key`. |
| `POST /v1/search/public` with no `X-Keenable-Title` | Add `X-Keenable-Title: <your app>`, or `?keenable_title=<your app>` if you can't set headers | The API returns `400` with `Missing app identifier`. |
| Retry a keyless hourly `429` in a loop | Wait for `limit.resets_at`, or send an API key | The hourly limit doesn't reset until that time. |
| Run a batch job on the keyless tier from a shared server | Use an API key | Every process on that IP address draws on the same 1,000 requests per hour. |
| Read `usage` from a keyless response | Read `usage` only on keyed calls | Keyless responses leave `usage` out. |

## API reference

* [Search without a key](https://docs.keenable.ai/api-reference/search.md#without-a-key) and [Fetch without a key](https://docs.keenable.ai/api-reference/fetch.md#without-a-key).
* [400 Missing app identifier](https://docs.keenable.ai/errors.md#400-missing-app-identifier) and [429 Rate limit exceeded](https://docs.keenable.ai/errors.md#429).
* [Authentication](https://docs.keenable.ai/authentication.md): add an API key when you outgrow the keyless tier.


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