# How to connect Tavily to OpenClaw (no MCP server to set up)

> Connect Tavily to OpenClaw with ClawLink: paste your Tavily API key once and 5 tools — search, extract, crawl, map, usage — work from chat. No OAuth app, no MCP server to run, nothing on your machine.

Web version: https://claw-link.dev/openclaw/tavily

The usual route to Tavily access for OpenClaw is an MCP server you configure and keep running, plus your own OAuth app or API keys. ClawLink gives OpenClaw a more practical Tavily setup: install one ClawHub skill, connect Tavily in the browser, and OpenClaw can call real Tavily actions from any chat surface with no auth, token refresh, or tool wiring to build yourself.

**Start here:** install the ClawLink plugin (`openclaw plugins install clawhub:clawlink-plugin`), pair it in the browser, then connect the app in the ClawLink dashboard. The interactive install prompt is on the web version of this page: https://claw-link.dev/openclaw/tavily

## Setup

It takes three steps to connect OpenClaw to Tavily.

1. **Install ClawLink** — add the plugin to OpenClaw once.
2. **Connect Tavily to OpenClaw (no MCP server** — one-click OAuth in the ClawLink dashboard.
3. **Use it from chat** — ask OpenClaw in plain English.

**Alternative for any agent (no plugin needed):** if the OpenClaw plugin route isn't available or doesn't work, any AI agent with shell access can use the ClawLink CLI instead:

```bash
npx -y @useclawlink/cli login          # sign in via browser — no API key to paste
npx -y @useclawlink/cli connect tavily  # connect Tavily to OpenClaw (no MCP server (browser OAuth)
npx -y @useclawlink/cli actions tavily  # list available actions
npx -y @useclawlink/cli run tavily <action> --input '<json>'  # execute (add --confirm for writes)
```

### Install by command

The setup prompt above does all of this in one paste. By hand, it is one install command plus a browser approval:

```bash
openclaw plugins install clawhub:clawlink-plugin
```

Then ask OpenClaw to set up ClawLink. It starts browser pairing and prints an approval link — open it, approve the device, return to the chat, and say `done`. Finally, connect Tavily in the [ClawLink dashboard](https://claw-link.dev/dashboard) — paste your Tavily API key once.

Verify the connection by asking OpenClaw:

> Use Tavily to search for the latest AI news, with max_results set to 8 and search_depth advanced, then summarize the top results with their source URLs.

### Using a different agent?

The OpenClaw plugin is one client of ClawLink's MCP server. Claude Code, Cursor, Codex, or any agent that can run a shell command pairs with the same ClawLink account through the CLI:

```bash
npx -y @useclawlink/cli login
```

`login` opens the same browser approval and stores a credential locally. Once Tavily is connected in the dashboard, that agent calls the same 5 Tavily tools over MCP. Full setup for MCP clients and shell agents: [connect apps to any AI agent](https://claw-link.dev/learn/connect-apps-to-any-ai-agent).

## Tavily MCP for OpenClaw

Looking for a Tavily MCP server for OpenClaw? ClawLink connects Tavily to OpenClaw and exposes 5 Tavily tools your agent can call over [MCP](https://claw-link.dev/learn/what-is-an-mcp-server), with [hosted auth](https://claw-link.dev/learn/oauth-for-ai-agents) and nothing to run or maintain yourself. Using Hermes instead? The [Hermes Tavily integration](https://claw-link.dev/hermes/tavily) uses the same hosted Tavily setup — paste your API key once — but Hermes pairs through its own CLI handshake rather than the OpenClaw skill flow.

Tavily has no OAuth; every route to it starts with an API key from app.tavily.com (a `tvly-...` string, free tier 1,000 credits a month), except Tavily's keyless mode, which sends an `X-Tavily-Access-Mode: keyless` header instead of a key. Keyless is real, free, and rate-limited, but it covers only search and extract; the crawl, map, and usage tools on this page have no keyless form, so a key is the route that gives an agent the full toolset. What differs otherwise is what happens next. The self-hosted route puts that key in `~/.openclaw/openclaw.json` or an environment variable and runs a plugin or MCP server that reads it. OpenClaw's own bug tracker has a live issue where the key is silently skipped when Brave is the `web_search` provider. ClawLink's route is shorter: create the key on Tavily's site, paste it once into the connect screen, and ClawLink stores it server-side. Five Tavily tools then work from chat with nothing running on your machine and nothing to resolve.

## The three other ways OpenClaw gets Tavily search

Every route needs a Tavily API key, except keyless access — the tradeoffs below are about what you run and what the agent can call.

- **Keyless access** (`X-Tavily-Access-Mode: keyless`): free, no account, covers search and extract only, and rate-limited without a visible budget. When you hit the cap you have to sign up for a key anyway. Fine for a quick script, not a standing agent tool.
- **OpenClaw's native route**: the bundled `@openclaw/tavily-plugin` gives `tavily_search` and `tavily_extract` (two tools), keyed via `~/.openclaw/openclaw.json` or `TAVILY_API_KEY`. Watch the unresolved-SecretRef bug above if you use Brave for `web_search`.
- **Tavily's official MCP server** (`tavily-ai/tavily-mcp`): search, extract, map, and crawl (four tools), run via `npx -y tavily-mcp` or the remote endpoint `https://mcp.tavily.com/mcp/?tavilyApiKey=...` — you configure it and keep it running.
- **Community plugins**: e.g. `openclaw-tavily` (five tools including `tavily_research`), installed with `openclaw plugins install openclaw-tavily` and keyed in its own config.
- **ClawLink (this page)**: five tools — search, extract, crawl, map, and `tavily_get_usage` — with the key stored server-side and nothing to run.

One honest gap: ClawLink's Tavily tools do not include Tavily's agentic Research endpoint. If you need multi-step research reports, the community plugin route above has `tavily_research`.

## What the OpenClaw Tavily integration can do

5 Tavily tools are ready for OpenClaw once the account is connected.

### All 5 Tavily tools for OpenClaw

| Tool | What it does |
|---|---|
| **Crawl** `tavily_crawl` | Tool to perform intelligent graph-based website crawling with parallel path exploration and content extraction. |
| **Extract** `tavily_extract` | Tool to extract and parse web page content from specified URLs using Tavily's extract endpoint. |
| **Get usage** `tavily_get_usage` | Tool to retrieve API key and account usage statistics from Tavily. |
| **Map** `tavily_map` | Tool to map a website and discover its pages. Use when you need to scan a website and get a structured list of URLs/pages it contains without extracting full content. |
| **Search** `tavily_search` | Use this to perform a web search via the Tavily API; offers controls for search depth, content types, result count, and domain filtering. Requires an active Tavily connection (401 = auth failure). |

## Example prompts

**Search the web**

> Use Tavily to search for the latest AI news, with max_results set to 8 and search_depth advanced, then summarize the top results with their source URLs.

**Search with domain control**

> Search Tavily for [your topic] but only include results from [domains], and exclude [domains]. Set include_answer true so the answer includes Tavily's AI summary.

**Extract a page**

> Extract the content of [url] as markdown and summarize it. If the page is a JavaScript-heavy SPA, set extract_depth to advanced first.

**Map and crawl a site**

> Map my website [url] with max_depth 2, then crawl only the /products section using select_paths and the instruction 'Focus on pricing details'.

## What the Tavily tools actually expect

Argument-level facts from the live Tavily schemas. The first two are the most common reasons a Tavily search looks incomplete.

- **`tavily_search` returns 5 results by default.** `max_results` defaults to 5, so "show me the latest AI news" comes back with exactly five links unless the agent sets it higher.
- **`include_answer` defaults to false — there is no AI summary unless you ask.** Combined with a basic `search_depth`, a plain "search for X" call returns the thinnest possible answer. If results look incomplete, check these two arguments before suspecting the connection.
- **`search_depth` defaults to `basic`** (1 Tavily credit). `advanced` costs 2 credits and returns more results with better relevance; on the free tier that halves the number of searches your monthly 1,000 credits cover.
- **Search results nest under `response_data.results`**, not a flat list — an agent that reads the top level of the response sees nothing and may report a failed search.
- **A 401 means the stored key is bad.** Tavily keys stop working when they are regenerated or revoked at app.tavily.com; reconnect from the dashboard with a fresh key. There are no scopes to check — Tavily keys have none.
- **A 429 is Tavily's rate limit, and reconnecting changes nothing.** Free/dev keys allow 100 requests per minute (production keys 1,000, and need a paid plan or PAYGO). The response carries a `retry-after` header; wait it out and retry with backoff.
- **`tavily_crawl` and `tavily_map` default to depth 1, breadth 20, `allow_external` true.** A bare "crawl my site" call walks one level of links and may follow off-site URLs; set `max_depth`, `select_paths`, and `select_domains` for a controlled crawl.
- **`tavily_extract` takes `urls` as an array** and times out at 30 seconds by default; `extract_depth: advanced` is the fix for JavaScript-rendered pages.
- **`tavily_get_usage` takes no arguments** and reports the credits left on the connected key — the only tool that reads Tavily's usage endpoint.
- **`topic` and `time_range` exist in OpenClaw's native plugin but not in ClawLink's `tavily_search`.** For news or recency, ask for the date window in the query instead.

## ClawLink vs. building it yourself

The alternative to ClawLink is usually manual API key setup plus your own token handling, permission troubleshooting, and tool plumbing for OpenClaw. That is fine if you want to build and maintain the integration yourself. Most teams just want Tavily working from chat.

| | Manual | ClawLink |
|---|---|---|
| **Credential handling** | Collect, validate, store, and rotate the Tavily API key yourself, then make sure every tool call uses the right account. | Users complete the hosted ClawLink setup once and the connected Tavily account becomes available to the agent without you building credential management. |
| **Ongoing maintenance** | You own refresh logic, permission debugging, environment config, and every provider-specific edge case for Tavily. | ClawLink handles the repetitive integration plumbing so your team can focus on the workflow instead of the infrastructure. |
| **Agent usability** | You still need to expose the right Tavily actions to the runtime in a format your agent can reliably use. | 5 tools for Tavily are already exposed through ClawLink, so the agent can read and act from chat immediately. |

## ClawLink vs. Composio

Composio also exposes Tavily to AI agents. It is developer infrastructure: Python and TypeScript SDKs, an MCP server, and a catalog past 1,000 apps, aimed at teams shipping agent products. ClawLink is built for OpenClaw users instead. You install the plugin once, connect Tavily in the browser, and the 5 tools above work from chat. There is no SDK and no config file, and the Tavily key you paste at setup is stored server-side rather than kept in your environment. Choosing between them? Read the full [Composio alternatives](https://claw-link.dev/hub/composio-alternatives) comparison.

### OpenClaw installed the Tavily skill but can't call the tools
The ClawHub skill teaches OpenClaw about Tavily, but the calls run through the ClawLink plugin and your connected account. Make sure Tavily is connected in the dashboard, then start a fresh chat so OpenClaw reloads the tool catalog. If OpenClaw runs as a persistent gateway, restart it so the new tools register.

### Connection succeeds but no tools appear
Reconnect Tavily from the dashboard, then start a fresh chat if the runtime still has the old tool catalog loaded.

### "Tool schema not loaded yet" error when calling Tavily tools
Tavily tool schemas load on demand the first time a tool runs and are cached after that, so this error usually clears on its own: wait a few seconds and retry the same request. If every Tavily call keeps failing with it in a fresh chat, reconnect from the dashboard, and contact support if it still persists — that pattern points to a configuration problem on our side, not something you can fix by reconnecting again.

### Tavily returns 403 or "permission denied" on one action while others work
Two usual causes. The connected account may not have access to the specific workspace, inbox, store, or project in the request — check that first. If access looks right, the agent may have sent a placeholder value (like "YOUR_ID" or an example id from documentation) instead of a real one: ask it to run a list or search tool first, then retry the action with a real id from those results. Most failures at this stage are one of these two, not ClawLink bugs.

### "No tavily connection is available. Connect it first."
The Tavily key was never added, or the connection was deleted. Open the dashboard, connect Tavily, paste a key from app.tavily.com (it starts with `tvly-`), and retry the same call in a fresh chat. This is the most common Tavily error we log, and it has nothing to do with the tools themselves.

### "Too many requests. Try again shortly." (HTTP 429 from Tavily)
Tavily's rate limit for free/development keys is 100 requests per minute, and every Tavily plan is metered in credits, so rapid bursts or a nearly empty balance both produce this. Wait for the `retry-after` interval and retry with backoff — three logged failures in our production logs arrived one minute apart from the same burst. Reconnecting the account changes nothing. To see where the credits went, call `tavily_get_usage`.

### "Tool 'tavily_tavily_search' not found. Did you mean: 'tavily_search', 'tavily_extract', 'tavily_get_usage'?"
The agent invented or doubled the tool name (integration name + tool name). The five real tools on this page are `tavily_search`, `tavily_extract`, `tavily_crawl`, `tavily_map`, and `tavily_get_usage`; the error message names the nearest real ones, so retrying with the suggested name works.

### 401 Unauthorized when calling Tavily tools
The stored API key is no longer valid. Tavily keys die when they are regenerated or revoked at app.tavily.com — and unlike OAuth there is no refresh token to save you. Reconnect Tavily from the dashboard with the current key.

### "plugins.entries.tavily.config.webSearch.apiKey: unresolved SecretRef" in the OpenClaw gateway log
This is the self-hosted OpenClaw route, not ClawLink: when `tools.web.search.provider` is set to Brave or any non-Tavily provider, OpenClaw's secrets resolver skips Tavily's key entirely (`SECRETS_REF_IGNORED_INACTIVE_SURFACE`, openclaw/openclaw issue #113864), so `tavily_search` and `tavily_extract` fail even with `TAVILY_API_KEY` set. If you are reading this error you are on the native plugin, and switching providers or the open fix PR #114283 is the way out. The ClawLink flow has no SecretRef step, so this failure cannot happen here.

### API key setup works but results look incomplete
Double-check that the API key for Tavily has the right scopes or account access. A valid key can still be too limited for some reads or writes.

### Is there a OpenClaw Tavily integration?
Yes. ClawLink is the fastest way to connect OpenClaw to Tavily: link your Tavily account once in the browser and OpenClaw can call the Tavily API through 5 ready-made tools — no custom code or token handling.

### How do I add Tavily to OpenClaw with ClawLink?
Paste the setup prompt from this page into OpenClaw. It installs the ClawLink Tavily skill from ClawHub, then you click Connect in the dashboard to authorize Tavily. OpenClaw calls the tools from the next message — no config files, and the Tavily key you paste is stored server-side instead of in your environment.

### How long does it take to connect Tavily to OpenClaw?
About two minutes. Sign in, click Connect next to Tavily in the dashboard, authenticate, and OpenClaw can use it from the next chat message.

### Why use ClawLink instead of wiring Tavily up myself?
The alternative to ClawLink is usually manual API key setup plus your own token handling, permission troubleshooting, and tool plumbing for OpenClaw. That is fine if you want to build and maintain the integration yourself. Most teams just want Tavily working from chat.

### Do I need a Tavily API key to connect Tavily to OpenClaw?
For the full toolset, yes. Tavily also has a keyless mode — a request with the `X-Tavily-Access-Mode: keyless` header, no key at all (docs.tavily.com/documentation/keyless) — but it covers only search and extract, is rate-limited with no visible budget, and ClawLink's connection takes a key precisely because the crawl, map, and usage tools have no keyless form. The key itself is free: app.tavily.com hands out 1,000 credits a month with no credit card, so the keyed route costs nothing up front and keeps every tool on this page available.

### How do I check how many Tavily credits I have left from chat?
Ask the agent to call `tavily_get_usage`. It reads Tavily's usage endpoint for the connected key and takes no arguments, so it is the fastest way to see whether a month of searches is nearly spent before you start blaming the tools.

### Can OpenClaw use Tavily without running an MCP server?
Yes — that is exactly what this page is. The ClawLink plugin exposes the five Tavily tools from chat with no MCP server to configure or keep running. If you prefer to run one yourself, Tavily's official `tavily-mcp` server and the remote endpoint `https://mcp.tavily.com/mcp/?tavilyApiKey=...` are the self-hosted alternatives.

### What is the difference between OpenClaw's built-in web_search and ClawLink's Tavily tools?
`web_search` is OpenClaw's generic search tool, with a provider you pick in config (Brave, Tavily, or others). ClawLink exposes Tavily's own tools — `tavily_search`, `tavily_extract`, `tavily_crawl`, `tavily_map`, `tavily_get_usage` — so the agent can control search depth, result count, domain filters, AI answers, crawling, and credit usage directly instead of through one generic interface.

### OpenClaw installed the Tavily skill but can't call the tools
The ClawHub skill teaches OpenClaw about Tavily, but the calls run through the ClawLink plugin and your connected account. Make sure Tavily is connected in the dashboard, then start a fresh chat so OpenClaw reloads the tool catalog. If OpenClaw runs as a persistent gateway, restart it so the new tools register.

## Related

- [PostHog](https://claw-link.dev/openclaw/posthog) — Track user behavior and feature flags
- [Connect DataforSEO](https://claw-link.dev/openclaw/dataforseo) — SEO data APIs for keywords, SERP, and site audits
- [Metabase](https://claw-link.dev/openclaw/metabase) — Metabase is an open-source business intelligence tool that lets you ask questions about your data and visualize answers as charts, graphs, and dashboards.
