> ## 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 Firecrawl to Keenable

> Move a Firecrawl integration to Keenable: map /scrape to GET /v1/fetch and /search to POST /v1/search, field by field, with before and after code.

Replace Firecrawl `/scrape` calls with Keenable's `GET /v1/fetch` and `/search` calls with `POST /v1/search`. This page maps each endpoint, 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 Firecrawl to Keenable. Read https://docs.keenable.ai/migrate/firecrawl.md for the endpoint, parameter and response maps. Replace every call with the Keenable SDK call or REST request it maps to, remove the 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

| | Firecrawl | Keenable |
| - | - | - |
| Page content | `POST https://api.firecrawl.dev/v2/scrape` with a JSON body | `GET https://api.keenable.ai/v1/fetch?url=...` with query parameters |
| Search | `POST /v2/search` with a JSON body | `POST /v1/search` with a JSON body. Only `query` is required. |
| Auth header | `Authorization: Bearer <token>` | `X-API-Key: $KEENABLE_API_KEY`, or no key on `/v1/search/public` and `/v1/fetch/public` |

## Endpoint map

| Firecrawl | Keenable | Match | Notes |
| - | - | - | - |
| `POST /v2/scrape` | `GET /v1/fetch` | Closest | Query parameters instead of a JSON body. The page comes back as markdown in `content`. |
| `POST /v2/search` | `POST /v1/search` | Exact | |

## Parameter map

A parameter Keenable doesn't list returns `400` with `Unknown parameter(s)`, so remove Firecrawl 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`

| Firecrawl parameter | Keenable | Match | Notes |
| - | - | - | - |
| `url` | `url` | Exact | URL-encode it when it has its own query string. |
| `formats` | None | None | Not needed for markdown: `content` is always markdown. `html`, `rawHtml`, `screenshot` and `links` have no equivalent. |
| `formats: summary` | `prompt` | Closest | `content` then holds only what the prompt asks for. The same goes for the `json` and `question` formats. |
| `onlyMainContent` | None | None | Not needed. `content` is the page's main text. |
| `maxAge` | `live` | Closest | `live=true` fetches the page from the source now, like `maxAge: 0`. Without it, Keenable returns its indexed copy when it has a usable one. |
| `timeout` | None | None | Set a timeout in your HTTP client or SDK instead. |
| `actions` | None | None | Remove it, along with `waitFor`, `mobile` and `headers`. |
| `location` | None | None | Remove it, along with `proxy`. |
| `parsers` | None | None | Remove it. |

### `POST /v1/search`

| Firecrawl parameter | Keenable | Match | Notes |
| - | - | - | - |
| `query` | `query` | Exact | Quoted phrases, `site:` and `-` work as operators in Keenable too. `inurl:`, `intitle:` and `filetype:` are plain words. |
| `limit` | `max_results` | Exact | Keenable takes `1` to `50`. |
| `includeDomains` | `site` | Closest | `site` takes one site. For several, put `site:a.com OR site:b.com` in `query`. |
| `excludeDomains` | `exclude_domains` | Exact | A list of host names. Each also covers its subdomains. |
| `tbs` | `published_after` | Closest | `qdr:h` becomes `1h`, `qdr:d` `1d`, `qdr:w` `1w`, `qdr:m` `1mo`, `qdr:y` `1y`. For a `cdr` range, send `published_after` and `published_before` as `YYYY-MM-DD`. |
| `safe` | `safety_mode` | Closest | `moderate` or `strict` instead of `true`. |
| `scrapeOptions` | None | None | Remove it. Each result's `snippet` already holds page text, capped by `snippet_max_length` (`180` to `10000`). For the full page, call `GET /v1/fetch` with its `url`. |
| `sources` | None | None | Keenable searches web pages only. |
| `categories` | None | None | Describe the kind of page in `query`, or use `site:` operators. |
| `location` | None | None | Remove it, along with `country`. |
| `timeout` | None | None | Set a timeout in your HTTP client or SDK instead. |
| `ignoreInvalidURLs` | None | None | Remove it, along with `highlights`. |

## Response map

### `GET /v1/fetch`

| Firecrawl field | Keenable | Match | Notes |
| - | - | - | - |
| `data.markdown` | `content` | Exact | At the top level, not under `data`. Capped by `max_chars`. |
| `data.metadata.title` | `title` | Exact | Left out when unknown. |
| `data.metadata.sourceURL` | `url` | Closest | The page's final URL after redirects, which can differ from the `url` you sent. |
| `data.metadata.statusCode` | None | None | A page Keenable can't read returns an error status. See [Fetch errors](https://docs.keenable.ai/api-reference/fetch.md#errors). |
| `data.metadata.description` | None | None | Keenable's `description` field is deprecated and always empty. |
| `data.html` | None | None | Keenable returns markdown only. |
| `success` | None | None | Read the HTTP status: `200` means the page came back. |

### `POST /v1/search`

| Firecrawl field | Keenable | Match | Notes |
| - | - | - | - |
| `data.web` | `results` | Closest | At the top level, not under `data`. |
| `data.web[].url` | `results[].url` | Exact | |
| `data.web[].title` | `results[].title` | Exact | |
| `data.web[].description` | `results[].snippet` | Closest | Markdown text from the page, capped by `snippet_max_length`. |
| `creditsUsed` | `usage.credits` | Closest | On calls made with a key. |
| `id` | The `X-Request-Id` response header | Closest | |
| `warning` | `warning` | Closest | Present only when the query wasn't run as a plain search. |

## Before and after

This request asks both APIs for one page as markdown. The Keenable request runs without a key and caps the content at 2,000 characters.

```bash Firecrawl (before) theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
curl -X POST https://api.firecrawl.dev/v2/scrape \
  -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://www.rfc-editor.org/rfc/rfc9110",
    "formats": ["markdown"]
  }'
```

```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/rfc9110" \
  --data-urlencode "max_chars=2000"
```

The Keenable response is one page object with `url`, `title` and `content`. `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 Firecrawl features have no Keenable counterpart. Remove them from the request, or handle them in your own code as described.

* `formats`: Fetch returns markdown only, with no HTML, screenshot, links or branding formats.
* `actions`: Fetch doesn't click, scroll, type or wait on a page.
* `location`: Neither endpoint takes a location, country or proxy choice.
* `sources`: Search returns web pages only, with no image or news sources.
* `categories`: Search has no categories. Describe the kind of page in `query`, or use `site:` operators.

Mapping checked on 2026-11-19 against [docs.firecrawl.dev/api-reference/endpoint/scrape](https://docs.firecrawl.dev/api-reference/endpoint/scrape), [docs.firecrawl.dev/api-reference/endpoint/search](https://docs.firecrawl.dev/api-reference/endpoint/search).

## 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/rfc9110", { maxChars: 2000 });
  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/rfc9110", max_chars=2000)
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/rfc9110",
		&keenable.FetchOptions{MaxChars: 2000})
	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/rfc9110",
            &FetchOptions {
                max_chars: Some(2000),
                ..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/rfc9110" \
  --data-urlencode "max_chars=2000"
```

You see the title of RFC 9110 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.markdown` and `data.metadata.title`.
4. Your code treats an error status as a page that couldn't be read, instead of checking `success`.
5. Your requests send no parameter from a None row. A leftover one returns `400` with `unknown_parameter`.
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. 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] Crawling a whole site
>
> Keenable has no crawl endpoint. Fetch takes one URL per request, so fetch each page you need. To find pages on one site, search with `site`.

> [accordion] Formats other than markdown
>
> Fetch returns markdown only. For a summary or structured fields, set `prompt`, and `content` holds only what the prompt asks for. 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.
* [Search API reference](https://docs.keenable.ai/api-reference/search.md): every search parameter and response field.
* [Fetch API reference](https://docs.keenable.ai/api-reference/fetch.md): every fetch parameter and response field.


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