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

# Migrate from Jina Reader to Keenable

> Move a Jina Reader integration to Keenable: map r.jina.ai to GET /v1/fetch and s.jina.ai to POST /v1/search, header by header, with before and after code.

Replace Jina Reader calls to `r.jina.ai` with Keenable's `GET /v1/fetch` and search calls to `s.jina.ai` with `POST /v1/search`. This page maps each endpoint, header, parameter and response field to Keenable, and shows the same request on both APIs.

## Migrate with your coding agent

Paste this prompt into your coding agent. Your agent reads this page as markdown and rewrites your calls.

```text theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
Migrate this project from Jina Reader to Keenable. Read https://docs.keenable.ai/migrate/jina.md for the endpoint, parameter and response maps. Replace every r.jina.ai and s.jina.ai call with the Keenable SDK call or REST request it maps to, remove the headers and parameters marked None, and read KEENABLE_API_KEY from the environment. Then run one request and show me the result. If a call fails, stop and show me the error.
```

Your agent finishes by running one Keenable request and showing you the result. The prompt works with Claude Code, Cursor, Codex and any other agent that can read a URL.

## What changes

| | Jina | Keenable |
| - | - | - |
| Page content | `GET https://r.jina.ai/<url>`, with the target URL in the path | `GET https://api.keenable.ai/v1/fetch?url=...`, with the target URL URL-encoded in `url` |
| Search | `GET https://s.jina.ai/<query>` or `POST https://s.jina.ai/search` | `POST /v1/search` with a JSON body. Only `query` is required. |
| Options | Request headers such as `X-Respond-With`, or camelCase fields such as `respondWith` in a JSON body | Query parameters on fetch, JSON body fields on search |
| Auth header | `Authorization: Bearer <key>`. Reading works without a key at a lower rate limit. Search needs a key. | `X-API-Key: $KEENABLE_API_KEY`, or no key on `/v1/search/public` and `/v1/fetch/public` |
| Response format | Plain text by default. JSON with `Accept: application/json`. | Always JSON |

## Endpoint map

| Jina | Keenable | Match | Notes |
| - | - | - | - |
| `GET r.jina.ai/{url}` | `GET /v1/fetch` | Closest | The target URL moves from the path to the `url` query parameter. `POST https://r.jina.ai/` with `url` in the body maps here too. |
| `GET s.jina.ai/{q}` | `POST /v1/search` | Closest | Results carry a `snippet`, not the full text of each page. `POST https://s.jina.ai/search` maps here too. |

## Parameter map

A parameter Keenable doesn't list returns `400` with `Unknown parameter(s)`, so remove Jina parameters instead of sending them along. "Closest" means the Keenable parameter does a similar job with a different format or behavior, described in the notes.

### `GET /v1/fetch`

| Jina parameter | Keenable | Match | Notes |
| - | - | - | - |
| `url` | `url` | Exact | URL-encode it when it has its own query string. |
| `X-No-Cache` | `live` | Closest | `live=true` fetches the page from the source now, like `X-No-Cache` or `X-Cache-Tolerance: 0`. Without it, Keenable returns its indexed copy when it has a usable one. |
| `X-Max-Tokens` | `max_chars` | Closest | `max_chars` caps `content` in characters, not tokens. `truncated` is `true` when the page was longer. |
| `X-Target-Selector` | None | None | Fetch takes no CSS selectors. To get one part of a page, describe it in `prompt`: a model reads the page and returns what you asked for, which can be reworded. |
| `X-Respond-With` | None | None | Not needed for markdown: `content` is always markdown. `html`, `text`, `screenshot` and `pageshot` have no equivalent. |
| `Accept` | None | None | Not needed. The response is always JSON. |
| `X-Remove-Selector` | None | None | Remove it, along with `X-Wait-For-Selector`. |
| `X-Engine` | None | None | Remove it, along with `X-Respond-Timing`. |
| `X-Timeout` | None | None | Set a timeout in your HTTP client or SDK instead. |
| `X-Token-Budget` | None | None | Cap the length of `content` with `max_chars` instead. |
| `X-Retain-Images` | None | None | Remove it, along with `X-Retain-Links`, `X-Retain-Media`, `X-With-Generated-Alt`, `X-With-Images-Summary` and `X-With-Links-Summary`. |
| `X-Proxy` | None | None | Remove it, along with `X-Proxy-Url` and `X-Locale`. |
| `X-Set-Cookie` | None | None | Remove it. |
| `X-Markdown-Chunking` | None | None | Split `content` in your own code. |
| `X-Preset` | None | None | Remove it. |

### `POST /v1/search`

| Jina parameter | Keenable | Match | Notes |
| - | - | - | - |
| `q` | `query` | Exact | Quoted phrases, `site:` and `-` work as operators in Keenable too. |
| `num` | `max_results` | Closest | Jina takes `0` to `20` and defaults to `10`. Keenable takes `1` to `50`, defaults to `10` and returns `400` for `0`, so skip the call where you sent `num=0`. `count` maps here too. |
| `site` | `site` | Closest | `site` takes one site. For several, put `site:a.com OR site:b.com` in `query`. The `X-Site` header maps here too. |
| `X-Respond-With` | None | None | Not needed. Every result carries a `snippet`, so `no-content` is the Keenable default. For a full page, call `GET /v1/fetch` with its `url`. |
| `filetype` | None | None | Remove it, along with `ext`, `intitle` and `loc`. In Keenable, `filetype:` and `intitle:` in `query` are plain words. |
| `type` | None | None | Keenable searches web pages only, with no `images` or `news` type. |
| `gl` | None | None | Remove it, along with `hl` and `location`. |
| `page` | None | None | Remove it. In Jina it picks a page of an uploaded file such as a PDF, and Keenable search takes no file uploads. |
| `provider` | None | None | Remove it, along with `fallback` and `nfpr`. |

## Response map

### `GET /v1/fetch`

| Jina field | Keenable | Match | Notes |
| - | - | - | - |
| `data.content` | `content` | Exact | Markdown, at the top level, not under `data`. Capped by `max_chars`. |
| `data.title` | `title` | Exact | Left out when unknown. |
| `data.url` | `url` | Closest | The page's final URL after redirects, which can differ from the `url` you sent. |
| `data.description` | None | None | Keenable's `description` field is deprecated and always empty. |
| `code` | None | None | Read the HTTP status: `200` means the page came back. See [Fetch errors](https://docs.keenable.ai/api-reference/fetch.md#errors). `status` goes too. |

### `POST /v1/search`

| Jina field | Keenable | Match | Notes |
| - | - | - | - |
| `data` | `results` | Closest | A top-level list of pages, best match first. |
| `data[].title` | `results[].title` | Exact | |
| `data[].url` | `results[].url` | Exact | |
| `data[].description` | `results[].snippet` | Closest | Markdown text from the page, capped by `snippet_max_length`. |
| `data[].content` | None | None | Call `GET /v1/fetch` with the result's `url`. |
| `data[].date` | `results[].published_at` | Closest | An ISO 8601 timestamp in UTC, not display text such as `Oct 9, 2025`. Left out when unknown. |
| `data[].usage` | `usage` | Closest | One object per call, on calls made with a key: `sku`, `amount`, `credits`, `paid`. Not a token count. |

## Before and after

This request asks both APIs for one page as markdown in JSON, read from the source now rather than from a cache. The Keenable request runs without a key, uses `live` where Jina uses `X-No-Cache`, and caps the content at 2,000 characters.

```bash Jina Reader (before) theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
curl https://r.jina.ai/https://www.rfc-editor.org/rfc/rfc9309 \
  -H "Authorization: Bearer $JINA_API_KEY" \
  -H "Accept: application/json" \
  -H "X-No-Cache: true"
```

```bash Keenable (after) theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
curl -G https://api.keenable.ai/v1/fetch/public \
  -H "X-Keenable-Title: My App" \
  --data-urlencode "url=https://www.rfc-editor.org/rfc/rfc9309" \
  --data-urlencode "max_chars=2000" \
  --data-urlencode "live=true"
```

The Keenable response is one page object with `url`, `title` and `content` at the top level, not under `data`. `content` is the page's main text as markdown, at most 2,000 characters, and `truncated` is `true` when the page was longer.

## No equivalent in Keenable

These Jina features have no Keenable counterpart. Remove them from the request, or handle them in your own code as described.

* `X-Respond-With`: Fetch returns markdown only, with no HTML, plain text or screenshot formats.
* `X-Target-Selector`: Fetch takes no CSS selectors. Describe the part you need in `prompt` instead: a model reads the page, so the answer can be reworded.
* `X-Engine`: Fetch has no engine, wait or timing choice.
* `type`: Search returns web pages only, with no image or news results.
* `gl`: Search has no country, language or location targeting.
* `page`: Search takes no uploaded files, so there is no page of a file to pick.

Mapping checked on 2026-11-19 against [github.com/jina-ai/reader/blob/main/README.md](https://github.com/jina-ai/reader/blob/main/README.md), [docs.jina.ai/api.md](https://docs.jina.ai/api.md), [s.jina.ai/openapi.json](https://s.jina.ai/openapi.json), [www.elastic.co/search-labs/tutorials/jina-tutorial/jina-reader](https://www.elastic.co/search-labs/tutorials/jina-tutorial/jina-reader).

## Use an SDK

This program sends the same fetch as the Keenable tab above with the official SDK. It runs without a key and prints the page's title and content.

```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 page = await client.fetch("https://www.rfc-editor.org/rfc/rfc9309", { maxChars: 2000, live: true });
  console.log(page.title);
  console.log(page.content);
}

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
page = client.fetch("https://www.rfc-editor.org/rfc/rfc9309", max_chars=2000, live=True)
print(page.title)
print(page.content)
```

```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()

	page, err := client.FetchWithOptions(context.Background(), "https://www.rfc-editor.org/rfc/rfc9309",
		&keenable.FetchOptions{MaxChars: 2000, Live: true})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(page.Title)
	fmt.Println(page.Content)
}
```

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

#[tokio::main]
async fn main() -> Result<(), keenable::Error> {
    let client = Client::new()?; // keyless: no API key needed to try it
    let page = client
        .fetch_with(
            "https://www.rfc-editor.org/rfc/rfc9309",
            &FetchOptions {
                max_chars: Some(2000),
                live: true,
                ..Default::default()
            },
        )
        .await?;
    println!("{}", page.title);
    println!("{}", page.content);
    Ok(())
}
```

```bash curl theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
curl -G https://api.keenable.ai/v1/fetch/public \
  -H "X-Keenable-Title: My App" \
  --data-urlencode "url=https://www.rfc-editor.org/rfc/rfc9309" \
  --data-urlencode "max_chars=2000" \
  --data-urlencode "live=true"
```

You see the title of RFC 9309 and up to 2,000 characters of its text as markdown. Install the SDK for your language from [SDKs](https://docs.keenable.ai/sdks.md).

## Verify the migration

Check each item before you remove the old client:

1. Run the Keenable request from [Before and after](#before-and-after). The status is `200`.
2. The body has `url`, `title` and `content`, and `content` is markdown of at most 2,000 characters.
3. Your code reads `content` and `title` at the top level, not `data.content` and `data.title`.
4. Code that read `data[].content` from a search now calls `GET /v1/fetch` for each result it needs in full.
5. Your requests send no parameter from a None row. A leftover one returns `400` with `unknown_parameter`. Remove leftover Jina `X-` headers too.
6. Change the path to `/v1/search` or `/v1/fetch` and send `X-API-Key`. The response gains a `usage` object. See [API keys](https://docs.keenable.ai/api-keys.md).

## Common questions

> [accordion] Trying Keenable without a key
>
> Send the request to `/v1/search/public` or `/v1/fetch/public` with an `X-Keenable-Title` header and no key. Search works without a key too. Without a key, each endpoint allows 1,000 requests per hour and 10 per second per IP address. See [Rate limits](https://docs.keenable.ai/rate-limits.md).

> [accordion] Full page text in search results
>
> Keenable search returns a `snippet` for each result, not the whole page. Raise `snippet_max_length`, up to `10000`, for more text per result, or call `GET /v1/fetch` with the `url` of each result you need in full. See [Search](https://docs.keenable.ai/products/search.md).

> [accordion] One part of a page
>
> Fetch takes no CSS selector. Set `prompt` to describe the part you need, such as "the pricing table", and `content` holds only that part. See [Fetch](https://docs.keenable.ai/products/fetch.md).

> [accordion] Cost of each call
>
> Each search mode and each kind of fetch is billed as its own SKU, and a call made with a key returns what it cost in `usage`. See [Pricing](https://docs.keenable.ai/pricing.md) and [Balance and usage](https://docs.keenable.ai/credits.md).

## Related

* [Migrate to Keenable](https://docs.keenable.ai/migrate.md): every provider Keenable has a mapping for.
* [Migrate from Firecrawl](https://docs.keenable.ai/migrate/firecrawl.md): another page-to-markdown API mapped to fetch.
* [Fetch API reference](https://docs.keenable.ai/api-reference/fetch.md): every fetch parameter and response field.
* [Search API reference](https://docs.keenable.ai/api-reference/search.md): every search parameter and response field.


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