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

# Keenable SDKs for Python, TypeScript, Go and Rust

> Install the official Keenable SDK for Python, TypeScript, Go or Rust with one command, search with no key, then add fetch, tool calling and Monitors.

The official SDKs give your code web search, page fetch and [Monitors](https://docs.keenable.ai/products/monitors) in Python, TypeScript, Go and Rust. Search results come back ready to paste into a prompt.

Each language has its own page with install, authentication, search, fetch, Monitors, webhook verification and error classes: [TypeScript](https://docs.keenable.ai/sdks/typescript.md), [Python](https://docs.keenable.ai/sdks/python.md), [Go](https://docs.keenable.ai/sdks/go.md) and [Rust](https://docs.keenable.ai/sdks/rust.md).

## What you get

* `search` returns ranked pages with their text extracted. `fetch` returns one page as markdown.
* `to_context()` renders results as numbered `[n] Title (url)` sources a model can cite.
* `TOOLS` holds OpenAI-format definitions for `keenable_search` and `keenable_fetch`. A helper runs whichever tool the model calls. See [Tool calling](https://docs.keenable.ai/tool-calling.md), with complete loops for [Anthropic](https://docs.keenable.ai/tool-calling/anthropic.md), [OpenAI](https://docs.keenable.ai/tool-calling/openai.md), [Gemini](https://docs.keenable.ai/tool-calling/gemini.md), [Mistral](https://docs.keenable.ai/tool-calling/mistral.md) and [Ollama or vLLM](https://docs.keenable.ai/tool-calling/open-models.md).
* In Python, `AsyncKeenable` has the same methods as the sync client. See [Async](#async). The Rust client is async and runs on Tokio.
* Search and fetch work with no account and no key. An API key raises your rate limit. Monitors needs a key.

## Install

Install the package for your language:

```bash TypeScript theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
npm install keenable
```

```bash Python theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
pip install keenable
```

```bash Go theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
go get github.com/keenableai/keenable-sdk/go@latest
```

```bash Rust theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
cargo add keenable
```

The SDKs need Python 3.9, Node 18, Go 1.22 or Rust 1.80, or newer. The TypeScript SDK has no runtime dependencies.

Keenable has no official SDK for other languages, such as Java, Ruby, PHP or C#. From those languages, call the HTTP API. See the [API reference](https://docs.keenable.ai/api-reference.md).

On macOS and many Linux distributions, system Python refuses a global `pip install`. If it does, install the package into a virtual environment: run `python3 -m venv .venv`, then `source .venv/bin/activate`. In an empty folder, run `go mod init example.com/demo` before `go get`. The Rust samples also need an async runtime: `cargo add tokio --features macros,rt-multi-thread`.

## Versions

These pages describe the SDKs as they are in the [SDK repository](https://github.com/keenableai/keenable-sdk). A package registry can hold an older release, and the install commands above take the latest one there. This table shows both versions for each language, and the command that prints the version you have:

| Language | Package | Latest release | SDK repository | Check your version |
| - | - | - | - | - |
| [TypeScript](https://docs.keenable.ai/sdks/typescript.md) | [npm](https://www.npmjs.com/package/keenable) | 0.1.4 | 0.2.0 | `npm ls keenable` |
| [Python](https://docs.keenable.ai/sdks/python.md) | [PyPI](https://pypi.org/project/keenable/) | 0.1.5 | 0.2.0 | `pip show keenable` |
| [Go](https://docs.keenable.ai/sdks/go.md) | [pkg.go.dev](https://pkg.go.dev/github.com/keenableai/keenable-sdk/go) | 0.2.0 | 0.2.0 | `go list -m github.com/keenableai/keenable-sdk/go` |
| [Rust](https://docs.keenable.ai/sdks/rust.md) | [crates.io](https://crates.io/crates/keenable) | 0.1.0 | 0.2.0 | `cargo tree -p keenable --depth 0` |

Release versions checked on 2026-11-19.

These SDK features are not in the latest release yet. The SDK pages mark each one with "Needs SDK" and the version:

| Language | Needs SDK | What |
| - | - | - |
| [TypeScript](https://docs.keenable.ai/sdks/typescript.md) | 0.1.5 or later | Automatic retries, `maxRetries`, `defaultHeaders` and per-call `timeoutMs` and `headers`; search `excludeDomains`, `disableCards` and `mode: "realtime"`; fetch `maxChars`, `live` and `prompt`; the error fields `code`, `type`, `fix`, `retryable`, `retryAfterSeconds`, `limit`, `requestId`, `param`, `value` and `reason`; `KeenableInsufficientCreditsError` and `KeenableTimeoutError`; `maxSnippetChars` and the text clean-up in `toContext()` |
| [TypeScript](https://docs.keenable.ai/sdks/typescript.md) | 0.2.0 or later | Search `objective`, Monitors and `verifyWebhook` |
| [Python](https://docs.keenable.ai/sdks/python.md) | 0.2.0 or later | Search `objective`, Monitors and `verify_webhook` |
| [Rust](https://docs.keenable.ai/sdks/rust.md) | 0.2.0 or later | Monitors and `verify_webhook` |

On an older release, a method marked "Needs SDK" doesn't exist, so the call fails. An option marked that way behaves differently in each language. Python raises a `TypeError` on the unknown keyword argument. In TypeScript it's a type error, but the npm package ignores an option it doesn't know, so plain JavaScript, or code TypeScript doesn't check, runs the call without it and raises no error. A search then comes back without the filter, and a fetch without the limit or prompt. Until a newer release is out, call the [API](https://docs.keenable.ai/api-reference.md) over HTTP for it. To check a webhook signature without the SDK, follow [Verify a webhook](https://docs.keenable.ai/products/monitors#verify-a-webhook).

## Run a keyless search

This program runs one search without a key and prints the top 3 results as a citable block:

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

async function main() {
  const client = new Keenable(); // keyless: no API key needed to try it
  const results = await client.search("fastest inference providers 2026", { maxResults: 3 });
  console.log(results.toContext());
}

main();
```

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

client = Keenable()  # keyless: no API key needed to try it
results = client.search("fastest inference providers 2026", max_results=3)
print(results.to_context())
```

```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() {
	client, err := keenable.New(nil) // keyless: no API key needed to try it
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	results, err := client.Search(context.Background(), "fastest inference providers 2026",
		&keenable.SearchOptions{MaxResults: 3})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(results.ToContext(nil))
}
```

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

#[tokio::main]
async fn main() -> Result<(), keenable::Error> {
    let client = Client::new()?; // keyless: no API key needed to try it
    let results = client
        .search_with(
            "fastest inference providers 2026",
            &SearchOptions {
                max_results: Some(3),
                ..Default::default()
            },
        )
        .await?;
    println!("{}", results.to_context());
    Ok(())
}
```

```bash curl theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
curl -X POST https://api.keenable.ai/v1/search/public \
  -H "Content-Type: application/json" \
  -H "X-Keenable-Title: My App" \
  -d '{"query": "fastest inference providers 2026", "max_results": 3}'
```

Save it in the directory where you installed the SDK and run it. In a new TypeScript project, `npx tsx index.ts` works as is: `npx` downloads `tsx` the first time, so you don't install it. To run the file with plain `node`, name it `index.mjs` or add `"type": "module"` to `package.json`, because the program uses a top-level `import`.

| Language | Save as | Run |
| - | - | - |
| TypeScript | `index.ts` | `npx tsx index.ts` |
| Python | `main.py` | `python main.py` |
| Go | `main.go` | `go run .` |
| Rust | `src/main.rs` | `cargo run` |
| curl | | Paste the command into a terminal. |

You see one `[n] Title (url)` header per result, followed by the page text:

```text Example output · results vary theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
[1] Hugging Face Inference Providers · Supported Models (https://huggingface.co/inference)
…

[2] Fastest LLM Inference Provider 2026: TTFT, tok/s, p99 (https://openbenchmarks.com/inference/fastest-inference-provider) - published 2026-09-03T00:00:00Z
Baseten recorded the lowest end-to-end p99 latency at 3.23 seconds on this run, with a median of 331 ms…

[3] Best LLM Inference Providers Compared for 2026 - SiliconFlow (https://siliconflow.com/articles/the-best-inference-provider-for-llms)
…
```

Each result has `title`, `url` and `snippet`, the page text extracted for the query, which is the field to put in a prompt. It also has `published_at` (`publishedAt` in TypeScript, `PublishedAt` in Go) and `acquired_at`, each an ISO 8601 UTC timestamp when the API has one. Results come back ranked, most relevant first. `description` is always empty and is deprecated, so read `snippet`.

To raise your limit, [create an API key](https://docs.keenable.ai/api-keys.md) and set `KEENABLE_API_KEY`. The code stays the same.

## Configuration

Every SDK reads two environment variables:

| Variable | Default | Purpose |
| - | - | - |
| `KEENABLE_API_KEY` | unset | Your API key. Unset means keyless. |
| `KEENABLE_API_URL` | `https://api.keenable.ai` | The API base URL. |

You can also pass settings to the constructor:

| Setting | Python | TypeScript | Go (`keenable.Options`) | Rust (`keenable::Options`) |
| - | - | - | - | - |
| API key | `api_key` | `apiKey` | `APIKey` (pointer) | `api_key` |
| Base URL | `base_url` | `baseUrl` | `BaseURL` (pointer) | `base_url` |
| Timeout | `timeout`, in seconds (default 30) | `timeoutMs` (default 30000) | `Timeout` (default 30s) | `timeout`, a `Duration` (default 30s) |
| Client source | `client_source` | `clientSource` | `ClientSource` | `client_source` |
| Your own HTTP client, for a proxy or custom transport | `client` (an `httpx.Client`) | `fetch` | `HTTPClient` (an `*http.Client`) | `http_client` (a `reqwest::ClientBuilder`) |

The SDK sends the client source as the `X-Keenable-Title` header. It defaults to `Keenable SDK`. If you build an integration on top of an SDK, set it to your product's name, so Keenable attributes the traffic to your product.

## Methods

| What it does | Python | TypeScript | Go | Rust |
| - | - | - | - | - |
| Search the web | `search(query, **filters)` | `search(query, options)` | `Search(ctx, query, *SearchOptions)` | `search(query)`, `search_with(query, &SearchOptions)` |
| Fetch one page | `fetch(url)` | `fetch(url)` | `Fetch(ctx, url)` | `fetch(url)`, `fetch_with(url, &FetchOptions)` |
| Render a citable block | `to_context()` | `toContext()` | `ToContext(nil)` | `to_context()` |
| List the results a block cites | `cited()` | `cited()` | `Cited(nil)` | `cited()` |
| Tool definitions | `TOOLS` | `TOOLS` | `Tools` | `tools()` |
| Run a tool call | `run_tool_call` (`arun_tool_call` for async) | `runToolCall` | `RunToolCall` | `run_tool_call` |

Search takes the [Search parameters](https://docs.keenable.ai/products/search.md#key-parameters), named in each language's style: `published_after` in Python and Rust, `publishedAfter` in TypeScript, `PublishedAfter` in Go. In Rust they are fields on `SearchOptions`. The same pattern holds for every parameter:

| Parameter | Python and Rust | TypeScript | Go | What it does |
| - | - | - | - | - |
| [Exclude domains](https://docs.keenable.ai/api-reference/search.md#exclude-domains) | `exclude_domains` | `excludeDomains` | `ExcludeDomains` | Leaves out these hosts. |
| Objective | `objective` | `objective` | `Objective` | Says what the search is for. Sent only when set. |
| Disable cards | `disable_cards` | `disableCards` | `DisableCards` | Returns ordinary web pages in place of cards. Sent only when true. |
| Mode | `mode` | `mode` | `Mode` | `pro` or `realtime`. |

In TypeScript, `disableCards` and `mode: "realtime"` need TypeScript SDK 0.1.5 or later.

The `keenable_search` tool offers `objective` and `disable_cards` to the model too.

In TypeScript, `excludeDomains`, `disableCards` and `mode: "realtime"`, and the tool's `exclude_domains` and `disable_cards`, need SDK 0.1.5 or later. `objective`, on search and in the tool, needs SDK 0.2.0 or later in TypeScript and Python.

`fetch` takes the [Fetch parameters](https://docs.keenable.ai/products/fetch.md#key-parameters) `max_chars`, `live` and `prompt`. Pass them as keyword arguments in Python, as `fetch(url, { maxChars, live, prompt })` in TypeScript, through `FetchWithOptions` and `FetchOptions` in Go, and through `fetch_with` and `FetchOptions` in Rust.

The `fetch` parameters need Python 0.1.5 or newer and TypeScript 0.1.5 or newer. Check the version you installed with `pip show keenable` or `npm ls keenable`. On an older version, `fetch` takes only the URL.

No SDK has a `session_id` argument. Send the `X-Keenable-Session-Id` header through the client's default headers (TypeScript from `keenable` 0.2.0). See [Group a run with a session ID](https://docs.keenable.ai/guides/high-volume-research.md#group-a-run-with-a-session-id).

### Context size

`to_context()` keeps a prompt small. It cleans each result's text first: it drops images, resolves relative links and flattens tables. It then cuts each result's text at a word boundary near 2,000 characters, ending it with "…", so one long page can't take the whole block. Last, it adds whole results in rank order. If a result would take the block past 12,000 characters, `to_context()` leaves out that result and every result after it, so the block never ends in the middle of a result. The first result is always kept, even if it's longer than the limit on its own.

`cited()` returns the results that `to_context()` kept, in the same order. Index 0 is the source the model cites as `[1]`.

You can change each limit per call:

| Limit | Default | Python | TypeScript | Go (`keenable.ContextOptions`) | Rust (`keenable::ContextOptions`) |
| - | - | - | - | - | - |
| Characters for the block | 12,000 | `max_chars` | `maxChars` | `MaxChars` | `max_chars` |
| Characters for each result | 2,000 | `max_snippet_chars` | `maxSnippetChars` | `MaxSnippetChars` | `max_snippet_chars` |
| Results to consider, from the top | All | `max_results` | `maxResults` | `MaxResults` (pointer) | `max_results` |
| Publication date in each header | Shown | `include_dates` | `includeDates` | `IncludeDates` (pointer) | `include_dates` |

To turn off the per-result cap, pass `None` in Python, `null` in TypeScript, a negative number in Go or `None` in Rust. In Go, `0` means the default.

The limits apply only to the rendered block. Each result's `snippet` keeps the full text. To get shorter text for each result from the API, pass `snippet_max_length` to search, from 180 to 10000 characters.

On a fetched page, `to_context()` takes only the character limit and cuts the page content at it.

In TypeScript, the per-result limit and the clean-up of images, links and tables need SDK 0.1.5 or later.

### Monitors

Every SDK has the [Monitors](https://docs.keenable.ai/products/monitors) API under `monitors`: `client.monitors` in Python and TypeScript, `client.Monitors` in Go, `client.monitors()` in Rust. It needs SDK version 0.2.0 or newer. On an older version there is no `monitors` property, so upgrade, or call the [Monitors API](https://docs.keenable.ai/api-reference/monitors/create.md) over HTTP with curl. Monitors needs an API key. Without one, a call fails with the SDK's authentication error and sends no request.

| What it does | Python | TypeScript | Go | Rust |
| - | - | - | - | - |
| [Create a monitor](https://docs.keenable.ai/api-reference/monitors/create.md) | `create(search=..., ...)` | `create({ search, ... })` | `Create(ctx, *MonitorCreateParams)` | `create(&MonitorCreateParams)` |
| [List monitors](https://docs.keenable.ai/api-reference/monitors/list.md) | `list()`, `list_all()` | `list()`, `listAll()` | `List`, `ListAll` | `list`, `list_all` |
| [Get](https://docs.keenable.ai/api-reference/monitors/get.md), [update](https://docs.keenable.ai/api-reference/monitors/update.md), [delete](https://docs.keenable.ai/api-reference/monitors/delete.md) | `get`, `update`, `delete` | `get`, `update`, `delete` | `Get`, `Update`, `Delete` | `get`, `update`, `delete` |
| [Pause, resume](https://docs.keenable.ai/api-reference/monitors/update.md) | `pause`, `resume` | `pause`, `resume` | `Pause`, `Resume` | `pause`, `resume` |
| [Start a run](https://docs.keenable.ai/api-reference/monitors/trigger.md), [read runs](https://docs.keenable.ai/api-reference/monitors/runs.md) and [one run](https://docs.keenable.ai/api-reference/monitors/run.md) | `trigger`, `runs`, `run` | `trigger`, `runs`, `run` | `Trigger`, `Runs`, `Run` | `trigger`, `runs`, `run` |
| [Read a monitor's results](https://docs.keenable.ai/api-reference/monitors/results.md) | `results` | `results` | `Results` | `results` |
| [Webhook deliveries](https://docs.keenable.ai/api-reference/monitors/deliveries.md), [counts](https://docs.keenable.ai/api-reference/monitors/stats.md), [bulk actions](https://docs.keenable.ai/api-reference/monitors/bulk.md) | `deliveries`, `stats`, `bulk` | `deliveries`, `stats`, `bulk` | `Deliveries`, `Stats`, `Bulk` | `deliveries`, `stats`, `bulk` |

`create` always sends an `Idempotency-Key`, either yours or a new one for each call, so the SDK can retry it safely. `update`, `pause`, `resume`, `trigger` and `bulk` are retried only after a `429`.

To verify a webhook delivery, call the package-level function, not a client method: `keenable.verify_webhook(...)` in Python, `verifyWebhook(...)` imported from `"keenable"` in TypeScript (it returns a promise), `keenable.VerifyWebhook(...)` in Go and `keenable::verify_webhook(...)` in Rust. It needs no client or API key. A failed check raises `WebhookVerificationError` (a `*WebhookVerificationError` in Go, `Error::WebhookVerification` in Rust). See [Verify a webhook](https://docs.keenable.ai/products/monitors#verify-a-webhook).

## Async

In Python, use `AsyncKeenable` when your code already runs on `asyncio`. It takes the same constructor settings as `Keenable`, and you `await` its `search` and `fetch`. If you pass your own HTTP client, pass an `httpx.AsyncClient`.

This program opens the client with `async with`, awaits one keyless search and prints each result's title and URL:

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

from keenable import AsyncKeenable


async def main():
    async with AsyncKeenable() as client:
        results = await client.search("httpx AsyncClient connection pooling", max_results=3)
        for result in results:
            print(result.title, result.url)


asyncio.run(main())
```

You see one line per result:

```text Example output · results vary theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
Python & HTTPX: How does httpx client's connection pooling work? https://stackoverflow.com/questions/69916682/python-httpx-how-does-httpx-clients-connection-pooling-work
Configuring httpx Limits and Pool Timeouts https://async-concurrency.com/network-io-protocol-handling/connection-pooling-and-keepalive/configuring-httpx-limits-and-pool-timeouts
Connection pooling with httpx.Client https://stackoverflow.com/questions/79595835/connection-pooling-with-httpx-client
```

The `async with` block closes the connection pool when it ends. If you create the client without `async with`, call `await client.aclose()` when you finish.

To run several searches at once with a cap on how many are in flight, see [Split a broad question into parallel searches](https://docs.keenable.ai/best-practices.md#split-a-broad-question-into-parallel-searches).

TypeScript, Go and Rust have one client each. In TypeScript, `search` and `fetch` return promises. In Go, `Search` and `Fetch` take a `context.Context` as their first argument. In Rust, `search` and `fetch` are `async` and need a Tokio runtime, such as `#[tokio::main]`.

## Errors

Every SDK raises typed errors that share one base class. In Rust, every call returns `keenable::Error`, an enum with one variant per case. See [Errors](https://docs.keenable.ai/errors.md) for what each status code means and how to fix it. The SDKs retry retryable errors and connection failures for you, up to 2 times by default. Monitor `update`, `pause`, `resume`, `trigger` and `bulk` are the exception: they're retried only after a `429`, as [Monitors](#monitors) says. See [Retry rules](https://docs.keenable.ai/errors.md#retry-rules) for the waits and how to turn retries off. Each language page says which errors the SDK retries on its own, for example [Python errors](https://docs.keenable.ai/sdks/python.md#errors).

| When | Python | TypeScript | Go | Rust |
| - | - | - | - | - |
| Base class | `KeenableError` | `KeenableError` | `keenable.Error` interface | `keenable::Error` enum |
| HTTP 429, rate limit exceeded | `KeenableRateLimitError` | `KeenableRateLimitError` | `RateLimitError` | `Error::RateLimit` |
| HTTP 401 or 403, key rejected | `KeenableAuthError` | `KeenableAuthError` | `AuthError` | `Error::Auth` |
| Any other non-2xx response | `KeenableAPIError` (`status_code`) | `KeenableAPIError` (`statusCode`) | `APIError` (`StatusCode`) | `Error::Api` (`status_code`) |
| HTTP 402, out of funds | `KeenableInsufficientCreditsError` | `KeenableInsufficientCreditsError` | `InsufficientCreditsError` | `Error::InsufficientCredits` |
| API could not be reached | `KeenableConnectionError` | `KeenableConnectionError` | `ConnectionError` | `Error::Connection` |
| Bad arguments, no request sent | `KeenableInvalidRequestError` | `KeenableInvalidRequestError` | `InvalidRequestError` | `Error::InvalidRequest` |

When the API rejects an `exclude_domains` entry, the API error carries `param` (`exclude_domains`), `value` (the rejected entry, or the list size for a size limit) and `reason`. They are `value` and `reason` in Python and TypeScript, `Value` and `Reason` on an `APIError` in Go, and `value` and `reason` on the `ApiError` in Rust (`err.api_error()`). Both are unset on every other error.

In TypeScript, `KeenableInsufficientCreditsError`, `KeenableTimeoutError`, `value` and `reason` need SDK 0.1.5 or later. So do every API error field other than `statusCode`, and `retryAfterSeconds` and `limit` on `KeenableRateLimitError`.

A 402 means the organization has used its allowance and its prepaid balance. Retrying fails the same way until someone tops up in the console. The SDKs don't pay per request: if the API offers a per-request payment, set `KEENABLE_API_KEY` instead. In Python and TypeScript, a timed-out request raises `KeenableTimeoutError`, a subclass of `KeenableConnectionError`.

## Source, packages and changelogs

| Language | README | Package | Changelog |
| - | - | - | - |
| Python | [python/README.md](https://github.com/keenableai/keenable-sdk/blob/main/python/README.md) | [PyPI](https://pypi.org/project/keenable/) | [python/CHANGELOG.md](https://github.com/keenableai/keenable-sdk/blob/main/python/CHANGELOG.md) |
| TypeScript | [typescript/README.md](https://github.com/keenableai/keenable-sdk/blob/main/typescript/README.md) | [npm](https://www.npmjs.com/package/keenable) | [typescript/CHANGELOG.md](https://github.com/keenableai/keenable-sdk/blob/main/typescript/CHANGELOG.md) |
| Go | [go/README.md](https://github.com/keenableai/keenable-sdk/blob/main/go/README.md) | [pkg.go.dev](https://pkg.go.dev/github.com/keenableai/keenable-sdk/go) | [go/CHANGELOG.md](https://github.com/keenableai/keenable-sdk/blob/main/go/CHANGELOG.md) |
| Rust | [rust/README.md](https://github.com/keenableai/keenable-sdk/blob/main/rust/README.md) | [crates.io](https://crates.io/crates/keenable) | [rust/CHANGELOG.md](https://github.com/keenableai/keenable-sdk/blob/main/rust/CHANGELOG.md) |

## Related pages

> [card] [Connect your agent (MCP)](https://docs.keenable.ai/mcp-server.md)
>
> Connect the Keenable MCP server to Claude Code, Cursor, Codex and other clients for web search and fetch with no key. Sign in for higher limits and Monitors.

> [card] [CLI](https://docs.keenable.ai/cli.md)
>
> Install the Keenable CLI, sign in once, add Keenable to Claude Code, Cursor and Codex over MCP, and search, fetch and run monitors from the terminal.

> [card] [LangChain](https://docs.keenable.ai/integrations/langchain.md)
>
> Give LangChain agents web search and page fetch with langchain-keenable: the KeenableSearch and KeenableFetch tools.


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