# Agents
Source: https://docs.tavily.com/agents

The canonical setup guide for AI agents and the developers who build them: choose how to connect to Tavily, choose the right capability, and use agent-grade defaults.

Tavily is the web layer for AI agents. Use Tavily when an agent needs live web **search**, page **extraction**, site **crawling**, site **mapping**, or cited **research**.

This page answers three questions, in order:

1. [Which Tavily docs should an agent fetch?](#1-agent-readable-docs)
2. [How should I connect to Tavily?](#2-choose-how-to-connect)
3. [Which Tavily capability should I use?](#3-choose-a-capability)

## 1. Agent-readable docs

Every Tavily docs page is also served as clean Markdown — append `.md` to any docs URL.

<Visibility>
  **Start here.** Use [`https://docs.tavily.com/llms.txt`](https://docs.tavily.com/llms.txt) as the documentation index, this page ([`agents.md`](https://docs.tavily.com/agents.md)) as the canonical setup guide, and [`https://docs.tavily.com/llms-full.txt`](https://docs.tavily.com/llms-full.txt) for the full text of all docs.

  | Resource                                                 | What it is                         | When to fetch it                                 |
  | -------------------------------------------------------- | ---------------------------------- | ------------------------------------------------ |
  | [`llms.txt`](https://docs.tavily.com/llms.txt)           | Compact index of every Tavily doc. | First, to find the right page.                   |
  | [`agents.md`](https://docs.tavily.com/agents.md)         | This setup guide.                  | When configuring Tavily or choosing a path.      |
  | [`llms-full.txt`](https://docs.tavily.com/llms-full.txt) | Full text of all docs.             | When you need broad context and have the budget. |
  | Page `.md` URLs                                          | Markdown version of one page.      | When you already know the page you need.         |
</Visibility>

<Visibility>
  The whole site is indexed in [llms.txt](/llms.txt), with the full text in [llms-full.txt](/llms-full.txt).
</Visibility>

## 2. Choose how to connect

Choose based on what Tavily must **do**, not only where you happen to be running.

<Visibility>
  <CardGroup>
    <Card title="SDK / API" icon="code" href="/documentation/api-reference/introduction">
      Build Tavily into an application, backend, or agent runtime that calls it in production. Get a free API key at [app.tavily.com](https://app.tavily.com).
    </Card>

    <Card title="MCP" icon="server" href="/documentation/mcp">
      Make Tavily available across a team or org — governed, shared, and reusable, including standardizing it for everyone's Cursor and Claude Code. Connect the remote server with OAuth or an API key.
    </Card>

    <Card title="CLI + Skills" icon="terminal" href="/documentation/agent-skills">
      Add Tavily to your own local coding or research session — for a single developer, not a team-wide rollout. Install the CLI and run `tvly login`.
    </Card>
  </CardGroup>
</Visibility>

<Visibility>
  | If you are…                                                                                                               | Use              | Why it fits                                                                             | Start at                                                                                                           |
  | ------------------------------------------------------------------------------------------------------------------------- | ---------------- | --------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
  | Building Tavily into an app, backend, or agent runtime that calls it in production                                        | **SDK / API**    | Your code calls Tavily directly at runtime. Get a free key at app.tavily.com.           | [`/documentation/api-reference/introduction`](https://docs.tavily.com/documentation/api-reference/introduction.md) |
  | Setting Tavily up for a team or org, or standardizing it across many agent clients (e.g. everyone's Cursor / Claude Code) | **MCP**          | Governed, shared, reusable access via the remote server (OAuth or API key).             | [`/documentation/mcp`](https://docs.tavily.com/documentation/mcp.md)                                               |
  | Adding Tavily to your own local coding or research session right now (single developer, not a team rollout)               | **CLI + Skills** | Terminal access to search, extract, and research; install the CLI and run `tvly login`. | [`/documentation/agent-skills`](https://docs.tavily.com/documentation/agent-skills.md)                             |
</Visibility>

**Quick rules**

* Production app or runtime → **SDK / API**.
* Shared across a team or org — even in Cursor or Claude Code → **MCP**.
* Just your own local session → **CLI + Skills**.
* Terminal access alone doesn't make CLI the right fit — match the choice to where Tavily ultimately needs to run.

<Tip>
  **Developer resource — Agent Toolkit.** [Agent Toolkit](/examples/agent-toolkit/overview) is for developers *building* production research agents, not for agents configuring Tavily autonomously. Reach for it when you need deeper research flows, retrieval orchestration, deduplication, summarization, or structured outputs.
</Tip>

## No account? Connect without a key

For autonomous agents that can't manage credentials, Tavily offers two no-key paths.

<Visibility>
  <CardGroup>
    <Card title="Keyless" icon="key" href="/documentation/keyless">
      Call Search and Extract with zero setup — send the `X-Tavily-Access-Mode: keyless` header, or connect the remote MCP with no key. No account required.
    </Card>

    <Card title="x402 payments" icon="credit-card" href="/documentation/machine-payments/x402">
      Pay per request for Advanced Search in USDC on Base — no API key, no account, no human in the loop.
    </Card>
  </CardGroup>
</Visibility>

<Visibility>
  | Path        | What it is                                                                                                           | Start at                                                                                                 |
  | ----------- | -------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
  | **Keyless** | Search and Extract with no account — send header `X-Tavily-Access-Mode: keyless`, or use the remote MCP with no key. | [`/documentation/keyless`](https://docs.tavily.com/documentation/keyless.md)                             |
  | **x402**    | Pay-per-request Advanced Search in USDC on Base over the x402 protocol — no key, no account, no human.               | [`/documentation/machine-payments/x402`](https://docs.tavily.com/documentation/machine-payments/x402.md) |
</Visibility>

## 3. Choose a capability

Lead with **Search** when sources are unknown; move to the others once you have URLs or a site to work through.

<Visibility>
  <CardGroup>
    <Card title="Search" icon="magnifying-glass" href="/documentation/api-reference/endpoint/search">
      Start here when sources are unknown or you need current web context.
    </Card>

    <Card title="Extract" icon="file-lines" href="/documentation/api-reference/endpoint/extract">
      Pull clean content when you already have the URL, or one from Search.
    </Card>

    <Card title="Map" icon="sitemap" href="/documentation/api-reference/endpoint/map">
      Discover a site's structure before crawling it.
    </Card>

    <Card title="Crawl" icon="spider-web" href="/documentation/api-reference/endpoint/crawl">
      Read many pages across a site.
    </Card>

    <Card title="Research" icon="flask-vial" href="/documentation/api-reference/endpoint/research">
      Get cited synthesis — a report, comparison, or decision-ready answer.
    </Card>
  </CardGroup>
</Visibility>

<Visibility>
  | Capability   | Use it when                                                                           | Reference                                                                                        |
  | ------------ | ------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
  | **Search**   | Sources are unknown or current web context is needed — the default start.             | [`/endpoint/search`](https://docs.tavily.com/documentation/api-reference/endpoint/search.md)     |
  | **Extract**  | You already have the URL, or picked one from Search.                                  | [`/endpoint/extract`](https://docs.tavily.com/documentation/api-reference/endpoint/extract.md)   |
  | **Map**      | You need a site's structure before crawling it.                                       | [`/endpoint/map`](https://docs.tavily.com/documentation/api-reference/endpoint/map.md)           |
  | **Crawl**    | Many pages on a site must be read.                                                    | [`/endpoint/crawl`](https://docs.tavily.com/documentation/api-reference/endpoint/crawl.md)       |
  | **Research** | The output should be cited synthesis: a report, comparison, or decision-ready answer. | [`/endpoint/research`](https://docs.tavily.com/documentation/api-reference/endpoint/research.md) |
</Visibility>

## Recommended defaults

These favor quality, which is what most agent workflows need. See [Best Practices for Search](/documentation/best-practices/best-practices-search) for the full reference.

* Prefer **`search_depth="advanced"`** for source discovery, comparisons, and high-confidence answers; use `"basic"` for quick lookups.
* For latency-sensitive use cases, **`fast`** and **`ultra-fast`** trade some relevance for lower latency.
* Add **`chunks_per_source=3`** with advanced Search for stronger evidence per source (chunks require advanced depth).
* Use **`max_results=5`** for focused answers, **`10`** for broader research.
* Use **`include_domains`** / **`exclude_domains`** when source trust matters.
* Prefer **Search → Extract** for grounded answers: Search to find sources, then Extract for full content.
* Avoid **`include_answer`** unless you need a quick answer seed — and still verify against sources.
* Use **Research** for cited synthesis: a report, comparison, or decision-ready answer.

A typical agent-grade Search call:

<CodeGroup>
  ```python Python theme={null}
  from tavily import TavilyClient

  client = TavilyClient(api_key="tvly-YOUR_API_KEY")
  response = client.search(
      "your query",
      search_depth="advanced",
      chunks_per_source=3,
      max_results=5,
  )
  ```

  ```javascript JavaScript theme={null}
  const { tavily } = require("@tavily/core");

  const tvly = tavily({ apiKey: "tvly-YOUR_API_KEY" });
  const response = await tvly.search("your query", {
    searchDepth: "advanced",
    chunksPerSource: 3,
    maxResults: 5,
  });
  ```

  ```bash cURL theme={null}
  curl --request POST \
    --url https://api.tavily.com/search \
    --header 'Authorization: Bearer tvly-YOUR_API_KEY' \
    --header 'Content-Type: application/json' \
    --data '{
      "query": "your query",
      "search_depth": "advanced",
      "chunks_per_source": 3,
      "max_results": 5
    }'
  ```
</CodeGroup>

## Availability

Some Tavily capabilities, limits, and defaults depend on your account, plan, or enterprise configuration. If a tool or parameter is unavailable, check the relevant endpoint docs and your account settings before retrying a different workflow.


# Changelog
Source: https://docs.tavily.com/changelog



<AccordionGroup>
  <Accordion title="Session tracking headers" icon="rocket" description="May 2026">
    <b><br />Attach session and end-user identifiers to your API requests — see <a href="/documentation/api-reference/introduction#session--user-tracking">Session Tracking</a></b><br />

    <ul>
      <li>
        Optionally tag any Tavily API request with HTTP headers so requests can be attributed back to a session or an end-user.
      </li>

      <li>
        <b><code>X-Session-Id</code></b> — opaque identifier for a session of related requests (e.g. all calls from one user conversation).
      </li>

      <li>
        <b><code>X-Human-Id</code></b> — opaque identifier for the end-user behind the request. Useful when a single API key serves many human users.
      </li>

      <li>
        Populated automatically when using the <a href="/documentation/mcp">Tavily MCP server</a> — local MCP generates a per-process session ID and forwards <code>HUMAN\_ID</code>; remote MCP derives the session ID from the MCP <code>initialize</code> handshake.
      </li>
    </ul>
  </Accordion>

  <Accordion title="Domain filtering and output length for Research" icon="rocket" description="May 2026">
    <b><br />[<code>include\_domains</code>](/documentation/api-reference/endpoint/research#body-include-domains), [<code>exclude\_domains</code>](/documentation/api-reference/endpoint/research#body-exclude-domains), and [<code>output\_length</code>](/documentation/api-reference/endpoint/research#body-output-length) parameters for [Research](/documentation/api-reference/endpoint/research)</b><br />

    <ul>
      <li>
        <b><code>include\_domains</code></b><br />

        <ul>
          <li><b>Type:</b> <code>array</code> of <code>string</code></li>
          <li><b>Default:</b> <code>\[]</code> — <b>Max:</b> 20 entries</li>
          <li>Soft preference for sources. The research agent prioritizes these domains, but URLs from other domains can still appear in the final report.</li>
          <li>Matching is host-based and includes subdomains (e.g. <code>sec.gov</code> matches <code>sec.gov</code> and <code>data.sec.gov</code>).</li>
        </ul>
      </li>

      <li>
        <b><code>exclude\_domains</code></b><br />

        <ul>
          <li><b>Type:</b> <code>array</code> of <code>string</code></li>
          <li><b>Default:</b> <code>\[]</code> — <b>Max:</b> 20 entries</li>
          <li>Hard blocklist. No URL from a listed domain or any of its subdomains appears in the response.</li>
          <li>Subdomain matching is downward only — blocking <code>medium.com</code> also blocks <code>blog.medium.com</code>, but blocking <code>blog.medium.com</code> leaves <code>medium.com</code> itself allowed.</li>
        </ul>
      </li>

      <li>
        <b><code>output\_length</code></b><br />

        <ul>
          <li><b>Type:</b> <code>string</code></li>
          <li><b>Options:</b> <code>short</code>, <code>standard</code>, <code>long</code></li>
          <li><b>Default:</b> <code>standard</code></li>
          <li>Typed control over response size. Ranges are targets, not hard caps — individual responses can fall outside when the question requires it.</li>
        </ul>
      </li>
    </ul>
  </Accordion>

  <Accordion title="Enterprise API key management endpoints" icon="rocket" description="March 2026">
    <b><br />Enterprise API key management — [Generate Keys](/documentation/enterprise/generate-keys), [Deactivate Keys](/documentation/enterprise/deactivate-keys), [Key Info](/documentation/enterprise/key-info)</b><br />

    <ul>
      <li>
        Enterprise users can programmatically manage API keys via dedicated endpoints.
      </li>

      <li>
        <b>[POST /generate-keys](/documentation/enterprise/generate-keys)</b> — Generate new API keys for your organization.
      </li>

      <li>
        <b>[POST /deactivate-keys](/documentation/enterprise/deactivate-keys)</b> — Deactivate existing API keys.
      </li>

      <li>
        <b>[GET /key-info](/documentation/enterprise/key-info)</b> — Retrieve information about an existing API key.
      </li>

      <li>
        These endpoints are available on the <b>Enterprise plan only</b>. [Talk to an expert](https://tavily.com/enterprise) to learn more.
      </li>
    </ul>
  </Accordion>

  <Accordion title="Exact match parameter" icon="rocket" description="February 2026">
    <b><br /><code>exact\_match</code> parameter for [Search](/documentation/api-reference/endpoint/search#body-exact-match)</b><br />

    <ul>
      <li>
        Use <code>exact\_match</code> to ensure that only search results containing the exact quoted phrase(s) in your query are returned, bypassing synonyms or semantic variations.
      </li>

      <li>
        Wrap target phrases in quotes within your query (e.g. <code>"John Smith" CEO Acme Corp</code>).
      </li>

      <li>
        <b>Type:</b> <code>boolean</code>
      </li>

      <li>
        <b>Default:</b> <code>false</code>
      </li>

      <li>
        Because this narrows retrieval, it may return fewer results or empty result fields when no exact matches are found.
      </li>

      <li>
        Best suited for due diligence, data enrichment, and legal/compliance use cases where verbatim matches are required.
      </li>
    </ul>
  </Accordion>

  <Accordion title="Project tracking with X-Project-ID header" icon="rocket" description="January 2026">
    <b><br />Track API usage by project with the new <code>X-Project-ID</code> header</b><br />

    <ul>
      <li>
        You can now attach a Project ID to your API requests to organize and track usage by project. This is useful when a single API key is used across multiple projects or applications.
      </li>

      <li>
        <b>HTTP Header:</b> Add <code>X-Project-ID: your-project-id</code> to any API request
      </li>

      <li>
        <b>Python SDK:</b> Pass <code>project\_id="your-project-id"</code> when instantiating the client, or set the <code>TAVILY\_PROJECT</code> environment variable
      </li>

      <li>
        <b>JavaScript SDK:</b> Pass <code>projectId: "your-project-id"</code> when instantiating the client, or set the <code>TAVILY\_PROJECT</code> environment variable
      </li>

      <li>
        An API key can be associated with multiple projects
      </li>

      <li>
        Filter requests by project in the [/usage endpoint](/documentation/api-reference/endpoint/usage) and platform usage dashboard to keep track of where requests originate from
      </li>
    </ul>
  </Accordion>

  <Accordion title="New search_depth options fast and ultra-fast (BETA)" icon="rocket" description="December 2025">
    <b><br />[<code>search\_depth</code> parameter](/documentation/api-reference/endpoint/search#body-search-depth) - New options: <code>fast</code> and <code>ultra-fast</code></b><br />

    <ul>
      <li>
        <b><code>fast</code> (BETA)</b><br />

        <ul>
          <li>Optimized for low latency while maintaining high relevance to the user query</li>
          <li><b>Cost:</b> 1 API Credit</li>
        </ul>
      </li>

      <li>
        <b><code>ultra-fast</code> (BETA)</b><br />

        <ul>
          <li>Optimized strictly for latency</li>
          <li><b>Cost:</b> 1 API Credit</li>
        </ul>
      </li>
    </ul>
  </Accordion>

  <Accordion title="Intent Based Extraction" icon="rocket" description="December 2025">
    <b><br />[<code>query</code>](/documentation/api-reference/endpoint/extract#body-query) and [<code>chunks\_per\_source</code>](/documentation/api-reference/endpoint/extract#body-chunks-per-source) parameters for Extract and Crawl</b><br />

    <ul>
      <li>
        <b><code>query</code> (Extract)</b><br />

        <ul>
          <li><b>Type:</b> <code>string</code></li>
          <li>User intent for reranking extracted content chunks. When provided, chunks are reranked based on relevance to this query.</li>
        </ul>
      </li>

      <li>
        <b><code>chunks\_per\_source</code> (Extract & Crawl)</b><br />

        <ul>
          <li><b>Type:</b> <code>integer</code></li>
          <li><b>Range:</b> 1 to 5</li>
          <li><b>Default:</b> 3</li>
          <li>Chunks are short content snippets (maximum 500 characters each) pulled directly from the source.</li>
          <li>Use <code>chunks\_per\_source</code> to define the maximum number of relevant chunks returned per source and to control the <code>raw\_content</code> length.</li>
          <li>Chunks will appear in the <code>raw\_content</code> field as: <code>\<chunk 1> \[...] \<chunk 2> \[...] \<chunk 3></code>.</li>
          <li>Available only when <code>query</code> is provided (Extract) or <code>instructions</code> are provided (Crawl).</li>
        </ul>
      </li>
    </ul>
  </Accordion>

  <Accordion title="Include usage parameter" icon="rocket" description="December 2025">
    <b><br />[<code>include\_usage</code> parameter](/documentation/api-reference/endpoint/search#body-include-usage)</b><br />

    <ul>
      <li>
        You can now include credit usage information in the API response for the [Search](/documentation/api-reference/endpoint/search#body-include-usage), [Extract](/documentation/api-reference/endpoint/extract#body-include-usage), [Crawl](/documentation/api-reference/endpoint/crawl#body-include-usage), and [Map](/documentation/api-reference/endpoint/map#body-include-usage) endpoints.
      </li>

      <li>
        Set the <code>include\_usage</code> parameter to <code>true</code> to receive credit usage information in the API response.
      </li>

      <li>
        <b>Type:</b> <code>boolean</code>
      </li>

      <li>
        <b>Default:</b> <code>false</code>
      </li>

      <li>
        When enabled, the response includes a <code>usage</code> object with <code>credits</code> information, making it easy to track API credit consumption for each request.
      </li>

      <li>
        <b>Note:</b> The value may be 0 if the total successful calls have not yet reached the minimum threshold. See our [Credits & Pricing documentation](/documentation/api-credits) for details.
      </li>
    </ul>
  </Accordion>

  <Accordion title="Vercel AI SDK v5 integration" icon="rocket" description="November 2025">
    <b><br />[Tavily is now integrated with Vercel AI SDK v5](/documentation/integrations/vercel)</b><br />

    <ul>
      <li>
        We've released a new [<code>@tavily/ai-sdk</code>](https://www.npmjs.com/package/@tavily/ai-sdk) package that provides pre-built AI SDK tools for Vercel's AI SDK v5.
      </li>

      <li>
        Easily add real-time web search, content extraction, intelligent crawling, and site mapping to your AI SDK project with ready-to-use tools.
      </li>

      <li>
        <b>Available Tools:</b> <code>tavilySearch</code>, <code>tavilyExtract</code>, <code>tavilyCrawl</code>, and <code>tavilyMap</code>
      </li>

      <li>
        Full TypeScript support with proper type definitions and seamless integration with Vercel AI SDK v5.
      </li>

      <li>
        Check out our [ integration guide](/documentation/integrations/vercel) to get started.
      </li>
    </ul>
  </Accordion>

  <Accordion title="Crawl & Map timeout parameter" icon="rocket" description="November 2025">
    <b><br />[<code>timeout</code> parameter for Crawl](/documentation/api-reference/endpoint/crawl#body-timeout) and [<code>timeout</code> parameter for Map](/documentation/api-reference/endpoint/map#body-timeout)</b><br />

    <ul>
      <li>
        You can now specify a custom timeout for the [Crawl](/documentation/api-reference/endpoint/crawl) and [Map](/documentation/api-reference/endpoint/map) endpoints to control how long to wait for the operation before timing out.
      </li>

      <li>
        <b>Type:</b> <code>float</code>
      </li>

      <li>
        <b>Range:</b> Between 10 and 150 seconds
      </li>

      <li>
        <b>Default:</b> 150 seconds
      </li>

      <li>
        This gives you fine-grained control over crawl and map operation timeouts, allowing you to balance between reliability and speed based on your specific use case.
      </li>
    </ul>
  </Accordion>

  <Accordion title="New team roles & permissions" icon="rocket" description="August 2025">
    <p /><b>Role options: Owner, Admin, Member</b>
    <p />You can now assign roles to team members, giving you more control over access and permissions. Each team has one owner, while there can be multiple admins and multiple members.
    The key distinction between roles is in their permissions for Billing and Settings:<p />

    <ul>
      <li>
        <b>Owner</b><br />

        <ul>
          <li>Full access to all Settings</li>
          <li>Access and ownership of the Billing account</li>
        </ul>
      </li>

      <li>
        <b>Admin</b><br />

        <ul>
          <li>Full access to Settings except ownership transfer</li>
          <li>No access to Billing</li>
        </ul>
      </li>

      <li>
        <b>Member</b><br />

        <ul>
          <li>Limited Settings access (view members only)</li>
          <li>No access to Billing</li>
        </ul>
      </li>
    </ul>
  </Accordion>

  <Accordion title="Extract timeout parameter" icon="rocket" description="August 2025">
    <b><br />[<code>timeout</code> parameter](/documentation/api-reference/endpoint/extract#body-timeout)</b><br />

    <ul>
      <li>
        You can now specify a custom timeout for the [Extract](/documentation/api-reference/endpoint/extract) endpoint to control how long to wait for URL extraction before timing out.
      </li>

      <li>
        <b>Type:</b> <code>number</code> (float)
      </li>

      <li>
        <b>Range:</b> Between 1.0 and 60.0 seconds
      </li>

      <li>
        <b>Default behavior:</b> If not specified, automatic timeouts are applied based on <code>extract\_depth</code>: 10 seconds for basic extraction and 30 seconds for advanced extraction.
      </li>

      <li>
        This gives you fine-grained control over extraction timeouts, allowing you to balance between reliability and speed based on your specific use case.
      </li>
    </ul>
  </Accordion>

  <Accordion title="Start date & end date Parameters" icon="rocket" description="July 2025">
    <b><br />[<code>start\_date</code> parameter](/documentation/api-reference/endpoint/search#body-start_date),[<code>end\_date</code> parameter](/documentation/api-reference/endpoint/search#body-end-date)</b><br />

    <ul>
      <li>
        You can now use both the <code>start\_date</code> and <code>end\_date</code> parameters in the [Search](/documentation/api-reference/endpoint/search) endpoints.
      </li>

      <li>
        <code>start\_date</code> will return all results after the specified start date. Required to be written in the format YYYY-MM-DD.
      </li>

      <li>
        <code>end\_date</code> will return all results before the specified end date. Required to be written in the format YYYY-MM-DD.
      </li>

      <li>
        Set <code>start\_date</code> to <code>2025-01-01</code> and <code>end\_date</code> to <code>2025-04-01</code> to reiceive results strictly from this time range.
      </li>
    </ul>
  </Accordion>

  <Accordion title="Usage dashboard" icon="rocket" description="July 2025">
    <b><br />[Login to your account to view the usage dashboard](https://www.tavily.com/)</b><br />
    <br />The usage dashboard provides the following features to paid users/teams:<br />

    <ul>
      <li>
        The Usage Graph offers a breakdown of daily usage across all Tavily endpoints with historical data to enable month over month usage and spend comparison.
      </li>

      <li>
        The Logs Table offers granular insight into each API request to ensure visibility and traceability with every Tavily interaction.
      </li>
    </ul>
  </Accordion>

  <Accordion title="Include favicon parameter" icon="rocket" description="June 2025">
    <b><br />[<code>include\_favicon</code> parameter](/documentation/api-reference/endpoint/search#body-include-favicon)</b><br />

    <ul>
      <li>
        You can now include the favicon URL for each result in the [Search](/documentation/api-reference/endpoint/search), [Extract](/documentation/api-reference/endpoint/extract), and [Crawl](/documentation/api-reference/endpoint/crawl) endpoints.
      </li>

      <li>
        Set the <code>include\_favicon</code> parameter to <code>true</code> to receive the favicon URL (if available) for each result in the API response.
      </li>

      <li>
        This makes it easy to display website icons alongside your search, extraction, or crawl results, improving the visual context and user experience in your application.
      </li>
    </ul>
  </Accordion>

  <Accordion title="Auto parameters" icon="rocket" description="June 2025">
    <b>Tavily Search<br />[<code>auto\_parameters</code>](/documentation/api-reference/endpoint/search#body-auto-parameters)</b><br />

    <ul>
      <li><b>Boolean default:</b> <code>false</code></li>
      <li>When <code>auto\_parameters</code> is enabled, Tavily automatically configures search parameters based on your query's content and intent. You can still set other parameters manually, and your explicit values will override the automatic ones.</li>
      <li>The parameters <code>include\_answer</code>, <code>include\_raw\_content</code>, and <code>max\_results</code> must always be set manually, as they directly affect response size.</li>
      <li><b>Note:</b> <code>search\_depth</code> may be automatically set to <code>advanced</code> when it's likely to improve results. This uses <b>2 API credits per request</b>. To avoid the extra cost, you can explicitly set <code>search\_depth</code> to <code>basic</code>.</li>
    </ul>
  </Accordion>

  <Accordion title="Usage endpoint" icon="rocket" description="May 2025">
    <b>[<code>/usage</code> endpoint](/documentation/api-reference/endpoint/usage)</b><br />

    <ul>
      <b>Easily check your API usage and plan limits.</b><br />Just <code>GET [https://api.tavily.com/usage](https://api.tavily.com/usage)</code> with your API key to monitor your account in real time.
    </ul>
  </Accordion>

  <Accordion title="Country parameter" icon="rocket" description="May 2025">
    <b>Tavily Search<br />[<code>country</code> parameter](/documentation/api-reference/endpoint/search#body-country)<br /><p>Boost search results from a specific country.</p></b>

    <ul>
      This will prioritize content from the selected country in the search results. Available only if <code>topic</code> is <code>general</code>.
    </ul>
  </Accordion>

  <Accordion title="Make & n8n integrations" icon="rocket" description="May 2025">
    <b>Make & n8n Integrations</b><br />

    <ul>
      <li>
        <b>[Tavily is now available for no-code integration through n8n.](/documentation/integrations/n8n)</b><br />
        <p>Integrate Tavily with n8n to enhance your workflows with real-time web search and content extraction—without writing code. With Tavily's powerful search and extraction capabilities, you can seamlessly integrate up-to-date online information into your n8n automations.</p>
      </li>

      <li>
        <b>[Integrate Tavily with Make without writing a single line of code.](/documentation/integrations/make)</b><br />
        <p>With Tavily's powerful search and content extraction capabilities, you can seamlessly integrate real-time online information into your Make workflows and automations.</p>
      </li>
    </ul>
  </Accordion>

  <Accordion title="Markdown format" icon="rocket" description="May 2025">
    <b>Tavily Extract<br />[<code>format</code> parameter](/documentation/api-reference/endpoint/extract#body-format)</b>

    <ul>
      <li><b>Type:</b> <code>enum\<string></code></li>
      <li><b>Default:</b> <code>markdown</code></li>
      <li>The format of the extracted web page content. <code>markdown</code> returns content in markdown format. <code>text</code> returns plain text and may increase latency.</li>
      <li><b>Available options:</b> <code>markdown</code>, <code>text</code></li>
    </ul>
  </Accordion>

  <Accordion title="Advanced search & chunks per source" icon="rocket" description="April 2025">
    <b>Tavily Search<br />[<code>search\_depth</code>](/documentation/api-reference/endpoint/search#body-search-depth) and [<code>chunks\_per\_source</code>](/documentation/api-reference/endpoint/search#body-chunks-per-source)parameters</b>

    <ul>
      <li>
        <b><code>search\_depth</code></b><br />

        <ul>
          <li><b>Type:</b> <code>enum\<string></code></li>
          <li><b>Default:</b> <code>basic</code></li>
          <li>The depth of the search. <code>advanced</code> search is tailored to retrieve the most relevant sources and content snippets for your query, while <code>basic</code> search provides generic content snippets from each source.</li>
          <li>A <code>basic</code> search costs 1 API Credit, while an <code>advanced</code> search costs 2 API Credits.</li>
          <li><b>Available options:</b> <code>basic</code>, <code>advanced</code></li>
        </ul>
      </li>

      <li>
        <b><code>chunks\_per\_source</code></b><br />

        <ul>
          <li>Chunks are short content snippets (maximum 500 characters each) pulled directly from the source.</li>
          <li>Use <code>chunks\_per\_source</code> to define the maximum number of relevant chunks returned per source and to control the content length.</li>
          <li>Chunks will appear in the content field as: <code>\<chunk 1> \[...] \<chunk 2> \[...] \<chunk 3></code>.</li>
          <li>Available only when <code>search\_depth</code> is <code>advanced</code>.</li>
          <li><b>Required range:</b> <code>1 \< x \< 3</code></li>
        </ul>
      </li>
    </ul>
  </Accordion>

  <Accordion title="Tavily crawl (BETA)" icon="rocket" description="April 2025">
    [Tavily Crawl](https://docs.tavily.com/documentation/api-reference/endpoint/crawl)<br />

    <ul>
      <li>
        Tavily Crawl enables you to traverse a website like a graph, starting from a base URL and automatically discovering and extracting content from multiple linked pages. With Tavily Crawl, you can:

        <ul>
          <li>Specify the starting URL and let the crawler intelligently follow links to map out the site structure.</li>
          <li>Control the depth and breadth of the crawl, allowing you to focus on specific sections or perform comprehensive site-wide analysis.</li>
          <li>Apply filters and custom instructions to target only the most relevant pages or content types.</li>
          <li>Aggregate extracted content for further analysis, reporting, or integration into your workflows.</li>
          <li>Seamlessly integrate with your automation tools or use the API directly for flexible, programmatic access.</li>
        </ul>

        Tavily Crawl is ideal for use cases such as large-scale content aggregation, competitive research, knowledge base creation, and more.<br />
        For full details and API usage examples, see the [Tavily Crawl API reference](https://docs.tavily.com/documentation/api-reference/endpoint/crawl).
      </li>
    </ul>
  </Accordion>
</AccordionGroup>


# About
Source: https://docs.tavily.com/documentation/about

Welcome to Tavily!

<Note>
  Looking for a step-by-step tutorial to get started in under 5 minutes? Head to our [Quickstart guide](/guides/quickstart) and start coding!
</Note>

## Who are we?

We're a team of AI researchers and developers passionate about helping you build the next generation of AI assistants.
Our mission is to empower individuals and organizations with accurate, unbiased, and factual information.

## What is the Tavily Search Engine?

Building an AI agent that leverages realtime online information is not a simple task. Scraping doesn't scale and requires expertise to refine, current search engine APIs don't provide explicit information to queries but simply potential related articles (which are not always related), and are not very customziable for AI agent needs. This is why we're excited to introduce the first search engine for AI agents - [Tavily](https://app.tavily.com).

Tavily is a search engine optimized for LLMs, aimed at efficient, quick and persistent search results. Unlike other search APIs such as Serp or Google, Tavily focuses on optimizing search for AI developers and autonomous AI agents. We take care of all the burden of searching, scraping, filtering and extracting the most relevant information from online sources. All in a single API call!

To try the API in action, you can now use our hosted version on our [API Playground](https://app.tavily.com/playground).

<Info>
  If you're an AI developer looking to integrate your application with our API, or seek increased API limits, [please reach out!](mailto:support@tavily.com)
</Info>

## Why choose Tavily?

Tavily shines where others fail, with a Search API optimized for LLMs.

<AccordionGroup>
  <Accordion title="Purpose-Built">
    Tailored just for LLM Agents, we ensure the search results are optimized for [RAG](https://towardsdatascience.com/retrieval-augmented-generation-intuitively-and-exhaustively-explain-6a39d6fe6fc9). We take care of all the burden in searching, scraping, filtering and extracting information from online sources. All in a single API call! Simply pass the returned search results as context to your LLM.
  </Accordion>

  <Accordion title="Versatility">
    Beyond just fetching results, the Tavily Search API offers precision. With customizable search depths, domain management, and parsing HTML content controls, you're in the driver's seat.
  </Accordion>

  <Accordion title="Performance">
    Committed to speed and efficiency, our API guarantees real-time and trusted information. Our team works hard to improve Tavily's performance over time.
  </Accordion>

  <Accordion title="Integration-friendly">
    We appreciate the essence of adaptability. That's why integrating our API with your existing setup is a breeze. You can choose our [Python library](https://pypi.org/project/tavily-python/), [JavaScript package](https://www.npmjs.com/package/@tavily/core) or a simple API call. You can also use Tavily through any of our supported partners such as [LangChain](/integrations/langchain) and [LlamaIndex](/integrations/llamaindex).
  </Accordion>

  <Accordion title="Transparent & Informative">
    Our detailed documentation ensures you're never left in the dark. From setup basics to nuanced features, we've got you covered.
  </Accordion>
</AccordionGroup>

## How does the Search API work?

Traditional search APIs such as Google, Serp and Bing retrieve search results based on a user query. However, the results are sometimes irrelevant to the goal of the search, and return simple URLs and snippets of content which are not always relevant. Because of this, any developer would need to then scrape the sites to extract relevant content, filter irrelevant information, optimize the content to fit LLM context limits, and more. This task is a burden and requires a lot of time and effort to complete. The Tavily Search API takes care of all of this for you in a single API call.

The Tavily Search API aggregates up to 20 sites per a single API call, and uses proprietary AI to score, filter and rank the top most relevant sources and content to your task, query or goal.
In addition, Tavily allows developers to add custom fields such as context and limit response tokens to enable the optimal search experience for LLMs.

Tavily can also help your AI agent make better decisions by including a short answer for cross-agent communication.

<Tip>
  With LLM hallucinations, it's crucial to optimize for RAG with the right context and information. This is where Tavily comes in, delivering accurate and precise information for your RAG applications.
</Tip>

## Getting started

[Sign up](https://app.tavily.com) for Tavily to get your API key. You get **1,000 free API Credits every month**. No credit card required.

<Card icon="key" href="https://app.tavily.com" title="Get your free API key">
  You get 1,000 free API Credits every month. **No credit card required.**
</Card>

Head to our [API Playground](https://app.tavily.com/playground) to familiarize yourself with our API.

To get started with Tavily's APIs and SDKs using code, head to our [Quickstart Guide](/guides/quickstart) and follow the steps.

<Note>
  Got questions? Stumbled upon an issue? Simply intrigued? Don't hesitate! Our support team is always on standby, eager to assist. Join us, dive deep, and redefine your search experience! [Contact us!](mailto:support@tavily.com)
</Note>


# Tavily Agent Skills
Source: https://docs.tavily.com/documentation/agent-skills

Official skills that define best practices, adding web search, extraction, crawling, and research to any AI coding agent.

<CardGroup>
  <Card title="GitHub" icon="github" href="https://github.com/tavily-ai/skills">
    `/tavily-ai/skills`
  </Card>

  <Card title="Get API Key" icon="key" href="https://app.tavily.com">
    Sign up at tavily.com
  </Card>
</CardGroup>

Agent Skills let you add Tavily's web capabilities to AI coding agents like Claude Code, Cursor, Cline, Codex, Windsurf, and others via the [Tavily CLI](https://docs.tavily.com/documentation/tavily-cli).

## Available Skills

| Skill                   | Description                                                                      |
| ----------------------- | -------------------------------------------------------------------------------- |
| `tavily-search`         | Web search with agent-optimized results.                                         |
| `tavily-extract`        | Extract clean markdown/text from URLs.                                           |
| `tavily-crawl`          | Crawl a website and extract content from multiple pages with semantic filtering. |
| `tavily-map`            | Discover and list all URLs on a website.                                         |
| `tavily-research`       | AI-powered research that produces a cited report.                                |
| `tavily-best-practices` | Reference docs for building production-ready Tavily integrations.                |

## Installation

### Step 1:

Install the Tavily CLI:

```bash theme={null}
curl -fsSL https://cli.tavily.com/install.sh | bash
```

See the [CLI docs](https://docs.tavily.com/documentation/tavily-cli) for other installation methods.

### Step 2:

Install the skills:

```bash theme={null}
npx skills add tavily-ai/skills --all
```

Or install a specific skill:

```bash theme={null}
npx skills add tavily-ai/skills --skill tavily-search
```

After installation, restart your AI agent to load the skills.

## Usage

Once installed, skills are automatically available to your agent. No additional configuration is needed — your agent will use them when appropriate based on your prompts.

### Automatic Invocation

Simply describe what you need and your agent will use the right Tavily skill:

```
Search for the latest news on AI regulations
```

```
Crawl the Stripe API docs and save them locally
```

```
Research the competitive landscape for AI coding assistants
```

### Explicit Skill Invocation

You can also invoke skills directly using slash commands:

```
/tavily-search current React best practices
```

```
/tavily-extract https://example.com/blog/post
```

```
/tavily-crawl https://docs.example.com
```

```
/tavily-research AI agent frameworks and save to report.json
```

```
/tavily-best-practices
```

## Skill Details

<AccordionGroup>
  <Accordion title="Search">
    Web search returning LLM-optimized results with content snippets and relevance scores.

    **Invoke explicitly:**

    ```
    /tavily-search
    ```

    **Example prompts:**

    * "Search for the latest news on AI regulations"
    * "/tavily-search current React best practices"
    * "Search for Python async patterns"

    **CLI usage:**

    ```bash theme={null}
    # Basic search
    tvly search "your query" --json

    # Advanced search with more results
    tvly search "quantum computing" --depth advanced --max-results 10 --json

    # Recent news
    tvly search "AI news" --time-range week --topic news --json

    # Domain-filtered
    tvly search "SEC filings" --include-domains sec.gov,reuters.com --json
    ```

    **Key options:** `--depth` (ultra-fast/fast/basic/advanced), `--max-results`, `--topic`, `--time-range`, `--include-domains`, `--exclude-domains`, `--include-raw-content`
  </Accordion>

  <Accordion title="Extract">
    Extract clean markdown or text content from one or more URLs. Handles JavaScript-rendered pages.

    **Invoke explicitly:**

    ```
    /tavily-extract
    ```

    **Example prompts:**

    * "Extract the content from this article URL"
    * "/tavily-extract [https://example.com/blog/post](https://example.com/blog/post)"
    * "Extract content from these three documentation pages"

    **CLI usage:**

    ```bash theme={null}
    # Single URL
    tvly extract "https://example.com/article" --json

    # Multiple URLs
    tvly extract "https://example.com/page1" "https://example.com/page2" --json

    # Query-focused extraction (returns relevant chunks only)
    tvly extract "https://example.com/docs" --query "authentication API" --chunks-per-source 3 --json
    ```

    **Key options:** `--query`, `--chunks-per-source`, `--extract-depth` (basic/advanced), `--format` (markdown/text)
  </Accordion>

  <Accordion title="Map">
    Discover URLs on a website without extracting content. Faster than crawling — useful for finding the right page before extracting.

    **Invoke explicitly:**

    ```
    /tavily-map
    ```

    **Example prompts:**

    * "Map the site structure of docs.example.com"
    * "Find the authentication page on this site"
    * "List all URLs under the /api/ path"

    **CLI usage:**

    ```bash theme={null}
    # Discover all URLs
    tvly map "https://docs.example.com" --json

    # With natural language filtering
    tvly map "https://docs.example.com" --instructions "Find API docs and guides" --json

    # Filter by path
    tvly map "https://example.com" --select-paths "/blog/.*" --limit 500 --json
    ```

    **Key options:** `--max-depth`, `--limit`, `--instructions`, `--select-paths`, `--exclude-paths`

    <Tip>Use the **map + extract** pattern: map to find the right page, then extract its content. This is often more efficient than crawling an entire site.</Tip>
  </Accordion>

  <Accordion title="Crawl">
    Crawl websites and extract content from multiple pages. Save each page as a local markdown file or get structured JSON output.

    **Invoke explicitly:**

    ```
    /tavily-crawl
    ```

    **Example prompts:**

    * "Crawl the Stripe API docs and save them locally"
    * "/tavily-crawl [https://docs.example.com](https://docs.example.com)"
    * "Download the Next.js documentation for offline reference"

    **CLI usage:**

    ```bash theme={null}
    # Save each page as a markdown file
    tvly crawl "https://docs.example.com" --output-dir ./docs/

    # Semantic focus (returns relevant chunks, not full pages)
    tvly crawl "https://docs.example.com" --instructions "Find authentication docs" --chunks-per-source 3 --json

    # Filter to specific paths
    tvly crawl "https://example.com" --select-paths "/api/.*,/guides/.*" --exclude-paths "/blog/.*" --json
    ```

    **Key options:** `--max-depth`, `--limit`, `--instructions`, `--chunks-per-source`, `--output-dir`, `--select-paths`, `--exclude-paths`
  </Accordion>

  <Accordion title="Research">
    AI-powered deep research that gathers sources, analyzes them, and produces a cited report. Takes 30–120 seconds.

    **Invoke explicitly:**

    ```
    /tavily-research
    ```

    **Example prompts:**

    * "Research the latest developments in quantum computing"
    * "/tavily-research AI agent frameworks and save to report.json"
    * "Research the competitive landscape for AI coding assistants"

    **CLI usage:**

    ```bash theme={null}
    # Basic research
    tvly research "competitive landscape of AI code assistants"

    # Pro model for comprehensive analysis
    tvly research "electric vehicle market analysis" --model pro

    # Stream results in real-time
    tvly research "AI agent frameworks comparison" --stream

    # Save report to file
    tvly research "fintech trends 2025" --model pro -o report.md
    ```

    **Key options:** `--model` (mini/pro/auto), `--stream`, `--citation-format`, `--output-schema`, `-o`
  </Accordion>

  <Accordion title="Tavily Best Practices">
    Build production-ready Tavily integrations with best practices baked in. Reference documentation for implementing web search, content extraction, crawling, and research in agentic workflows, RAG systems, or autonomous agents.

    **Invoke explicitly:**

    ```
    /tavily-best-practices
    ```

    **Example prompts:**

    * "Add Tavily search to my internal company chatbot so it can answer questions about our competitors"
    * "Build a lead enrichment tool that uses Tavily to find company information from their website"
    * "Create a news monitoring agent that tracks mentions of our brand using Tavily search"
    * "Implement a RAG pipeline that uses Tavily extract to pull content from industry reports"
  </Accordion>
</AccordionGroup>

## What You Can Build

Copy-paste these prompts into your AI agent and start building:

<AccordionGroup>
  <Accordion title="AI Chatbot with Real-Time Search">
    Build a chatbot that can answer questions about current events and up-to-date information.

    **Try these prompts:**

    ```
    /tavily-best-practices Build a chatbot that integrates Tavily search to answer questions with up-to-date web information
    ```

    ```
    /tavily-best-practices Add Tavily search to my internal company chatbot so it can answer questions about our competitors
    ```
  </Accordion>

  <Accordion title="News Dashboard with Sentiment Analysis">
    Create a live news dashboard that tracks topics and analyzes sentiment.

    **Try these prompts:**

    ```
    /tavily-best-practices Build a website that refreshes daily with Tesla news and gives a sentiment score on each article
    ```

    ```
    /tavily-best-practices Create a news monitoring dashboard that tracks AI industry news and sends daily Slack summaries
    ```
  </Accordion>

  <Accordion title="Lead Enrichment Tool">
    Build tools that automatically enrich leads with company data from the web.

    **Try these prompts:**

    ```
    /tavily-best-practices Build a lead enrichment tool that uses Tavily to find company information from their website
    ```

    ```
    /tavily-best-practices Create a script that takes a list of company URLs and extracts key business information
    ```
  </Accordion>

  <Accordion title="Competitive Intelligence Agent">
    Build an autonomous agent that monitors competitors and surfaces insights.

    **Try these prompts:**

    ```
    /tavily-best-practices Build a market research tool that crawls competitor documentation and pricing pages
    ```

    ```
    /tavily-best-practices Create an agent that monitors competitor product launches and generates weekly reports
    ```
  </Accordion>
</AccordionGroup>

<Tip>
  The `/tavily-best-practices` skill is your fastest path to production. Describe what you want to build and your agent generates working code with best practices baked in.
</Tip>


# Credits & Pricing
Source: https://docs.tavily.com/documentation/api-credits

Learn how to get and manage your Tavily API Credits.

## Free API Credits

<Card icon="key" href="https://app.tavily.com" title="Get your free API key">
  You get 1,000 free API Credits every month. **No credit card required.**
</Card>

## Pricing Overview

Tavily operates on a simple, credit-based model:

* **Free**: 1,000 credits/month
* **Pay-as-you-go**: \$0.008 per credit (allows you to be charged per credit once your plan’s credit limit is reached).
* **Monthly plans**: \$0.0075 - \$0.005 per credit
* **Enterprise**: Custom pricing and volume

| **Plan**          | **Credits per month** | **Monthly price** | **Price per credit** |
| ----------------- | --------------------- | ----------------- | -------------------- |
| **Researcher**    | 1,000                 | Free              | -                    |
| **Project**       | 4,000                 | \$30              | \$0.0075             |
| **Bootstrap**     | 15,000                | \$100             | \$0.0067             |
| **Startup**       | 38,000                | \$220             | \$0.0058             |
| **Growth**        | 100,000               | \$500             | \$0.005              |
| **Pay as you go** | Per usage             | \$0.008 / Credit  | \$0.008              |
| **Enterprise**    | Custom                | Custom            | Custom               |

Head to [billing](https://app.tavily.com/billing) to explore our different options and manage your plan.

## API Credits Costs

### Tavily Search

Your [search depth](/api-reference/endpoint/search#body-search-depth) determines the cost of your request.

* **Basic Search (`basic`):**
  Each request costs **1 API credit**.

* **Advanced Search (`advanced`):**
  Each request costs **2 API credits**.

### Tavily Extract

The number of successful URL extractions and your [extraction depth](/api-reference/endpoint/extract#body-extract-depth) determines the cost of your request. You never get charged if a URL extraction fails.

* **Basic Extract (`basic`):**
  Every 5 successful URL extractions cost **1 API credit**

* **Advanced Extract (`advanced`):**
  Every 5 successful URL extractions cost **2 API credits**

### Tavily Map

The number of pages mapped and whether or not natural-language [instructions](/documentation/api-reference/endpoint/map#instructions) are specified determines the cost of your request. You never get charged if a map request fails.

* **Regular Mapping:**
  Every 10 successful pages returned cost **1 API credit**

* **Map with (`instructions`):**
  Every 10 successful pages returned cost **2 API credits**

### Tavily Crawl

Tavily Crawl combines both mapping and extraction operations, so the cost is the sum of both:

* **Crawl Cost = Mapping Cost + Extraction Cost**

For example:

* If you crawl 10 pages with basic extraction depth, you'll be charged **1 credit for mapping** (10 pages) + **2 credits for extraction** (10 successful extractions ÷ 5) = **3 total credits**
* If you crawl 10 pages with advanced extraction depth, you'll be charged **1 credit for mapping** + **4 credits for extraction** = **5 total credits**

### Tavily Research

Tavily Research follows a dynamic
pricing model with minimum and maximum credit consumption boundaries associated
with each request. The minimum and maximum boundaries differ based on if the
request uses `model=mini` or `model=pro`.

| Request Cost Boundaries | model=pro   | model=mini  |
| ----------------------- | ----------- | ----------- |
| Per-request minimum     | 15 credits  | 4 credits   |
| Per-request maximum     | 250 credits | 110 credits |


# Tavily Crawl
Source: https://docs.tavily.com/documentation/api-reference/endpoint/crawl

POST /crawl
Tavily Crawl is a graph-based website traversal tool that can explore hundreds of paths in parallel with built-in extraction and intelligent discovery.



# Tavily Extract
Source: https://docs.tavily.com/documentation/api-reference/endpoint/extract

POST /extract
Extract web page content from one or more specified URLs using Tavily Extract.



# Tavily Map
Source: https://docs.tavily.com/documentation/api-reference/endpoint/map

POST /map
Tavily Map traverses websites like a graph and can explore hundreds of paths in parallel with intelligent discovery to generate comprehensive site maps.



# Create Research Task
Source: https://docs.tavily.com/documentation/api-reference/endpoint/research

POST /research
Tavily Research performs comprehensive research on a given topic by conducting multiple searches, analyzing sources, and generating a detailed research report.

## Files

Attach files to a research request and the agent uses their contents as a source alongside the web. Add a `files` array to the request body, where each entry carries a filename and its base64-encoded contents. The agent reads the relevant parts of each file, grounds its answer in them, and cites any file it draws from.

**Supported file types:** `.txt`, `.md`, `.json`

Up to 5 files per request.

### Full Request

```json theme={null}
{
  "input": "Summarize the key risks in the attached report and compare them to recent industry coverage.",
  "files": [
    {
      "name": "q1-report.md",
      "data": "<base64-encoded file contents>",
      "type": "base64"
    }
  ]
}
```

### Limits

| Limit                                           | Value        |
| ----------------------------------------------- | ------------ |
| Max files per request                           | 5            |
| Max size per text file (`.txt`, `.md`, `.json`) | 80,000 words |
| Max combined size of all files                  | 80,000 words |


# Get Research Task Status
Source: https://docs.tavily.com/documentation/api-reference/endpoint/research-get

GET /research/{request_id}
Retrieve the status and results of a research task using its request ID.



# Streaming
Source: https://docs.tavily.com/documentation/api-reference/endpoint/research-streaming

Stream real-time research progress and results from Tavily Research API

## Overview

When using the Tavily Research API, you can stream responses in real-time by setting `stream: true` in your request. This allows you to receive research progress updates, tool calls, and final results as they're generated, providing a better user experience for long-running research tasks.

Streaming is particularly useful for:

* Displaying research progress to users in real-time
* Monitoring tool calls and search queries as they execute
* Receiving incremental updates during lengthy research operations
* Building interactive research interfaces

## Enabling Streaming

To enable streaming, set the `stream` parameter to `true` when making a request to the Research endpoint:

```json theme={null}
{
  "input": "What are the latest developments in AI?",
  "stream": true
}
```

The API will respond with a `text/event-stream` content type, sending Server-Sent Events (SSE) as the research progresses.

## Event Structure

Each streaming event follows a consistent structure compatible with the OpenAI chat completions format:

```json theme={null}
{
  "id": "123e4567-e89b-12d3-a456-426614174111",
  "object": "chat.completion.chunk",
  "model": "mini",
  "created": 1705329000,
  "choices": [
    {
      "delta": {
        // Event-specific data here
      }
    }
  ]
}
```

### Core Fields

| Field     | Type    | Description                                           |
| --------- | ------- | ----------------------------------------------------- |
| `id`      | string  | Unique identifier for the stream event                |
| `object`  | string  | Always `"chat.completion.chunk"` for streaming events |
| `model`   | string  | The research model being used (`"mini"` or `"pro"`)   |
| `created` | integer | Unix timestamp when the event was created             |
| `choices` | array   | Array containing the delta with event details         |

## Event Types

The streaming response includes different types of events in the `delta` object. Here are the main event types you'll encounter:

### 1. Tool Call Events

When the research agent performs actions like web searches, you'll receive tool call events:

```json theme={null}
{
  "id": "evt_002",
  "object": "chat.completion.chunk",
  "model": "mini",
  "created": 1705329005,
  "choices": [
    {
      "delta": {
        "role": "assistant",
        "tool_calls": {
          "type": "tool_call",
          "tool_call": [
            {
              "name": "WebSearch",
              "id": "fc_633b5932-e66c-4523-931a-04a7b79f2578",
              "arguments": "Executing 5 search queries",
              "queries": ["latest AI developments 2024", "machine learning breakthroughs", "..."]
            }
          ]
        }
      }
    }
  ]
}
```

**Tool Call Delta Fields:**

| Field                 | Type   | Description                                                        |
| --------------------- | ------ | ------------------------------------------------------------------ |
| `type`                | string | Either `"tool_call"` or `"tool_response"`                          |
| `tool_call`           | array  | Details about the tool being invoked                               |
| `name`                | string | Name of the tool (see [Tool Types](#tool-types) below)             |
| `id`                  | string | Unique identifier for the tool call                                |
| `arguments`           | string | Description of the action being performed                          |
| `queries`             | array  | *(WebSearch only)* The search queries being executed               |
| `parent_tool_call_id` | string | *(Pro mode only)* ID of the parent tool call for nested operations |

### 2. Tool Response Events

After a tool executes, you'll receive response events with discovered sources:

```json theme={null}
{
  "id": "evt_003",
  "object": "chat.completion.chunk",
  "model": "mini",
  "created": 1705329010,
  "choices": [
    {
      "delta": {
        "role": "assistant",
        "tool_calls": {
          "type": "tool_response",
          "tool_response": [
            {
              "name": "WebSearch",
              "id": "fc_633b5932-e66c-4523-931a-04a7b79f2578",
              "arguments": "Completed executing search tool call",
              "sources": [
                {
                  "url": "https://example.com/article",
                  "title": "Example Article",
                  "favicon": "https://example.com/favicon.ico"
                }
              ]
            }
          ]
        }
      }
    }
  ]
}
```

**Tool Response Fields:**

| Field                 | Type   | Description                                                     |
| --------------------- | ------ | --------------------------------------------------------------- |
| `name`                | string | Name of the tool that completed                                 |
| `id`                  | string | Unique identifier matching the original tool call               |
| `arguments`           | string | Completion status message                                       |
| `sources`             | array  | Sources discovered by the tool (with `url`, `title`, `favicon`) |
| `parent_tool_call_id` | string | *(Pro mode only)* ID of the parent tool call                    |

### 3. Content Events

The final research report is streamed as content chunks:

```json theme={null}
{
  "id": "evt_004",
  "object": "chat.completion.chunk",
  "model": "mini",
  "created": 1705329015,
  "choices": [
    {
      "delta": {
        "role": "assistant",
        "content": "# Research Report\n\nBased on the latest sources..."
      }
    }
  ]
}
```

**Content Field:**

* Can be a **string** (markdown-formatted report chunks) when no `output_schema` is provided
* Can be an **object** (structured data) when an `output_schema` is specified

### 4. Sources Event

After the content is streamed, a sources event is emitted containing all sources used in the research:

```json theme={null}
{
  "id": "evt_005",
  "object": "chat.completion.chunk",
  "model": "mini",
  "created": 1705329020,
  "choices": [
    {
      "delta": {
        "role": "assistant",
        "sources": [
          {
            "url": "https://example.com/article",
            "title": "Example Article Title",
            "favicon": "https://example.com/favicon.ico"
          }
        ]
      }
    }
  ]
}
```

**Source Object Fields:**

| Field     | Type   | Description                  |
| --------- | ------ | ---------------------------- |
| `url`     | string | The URL of the source        |
| `title`   | string | The title of the source page |
| `favicon` | string | URL to the source's favicon  |

### 5. Done Event

Signals the completion of the streaming response:

```
event: done
```

## Tool Types

During research, you'll encounter the following tool types in streaming events:

| Tool Name          | Description                                                    | Model    |
| ------------------ | -------------------------------------------------------------- | -------- |
| `Planning`         | Initializes the research plan based on the input query         | Both     |
| `Generating`       | Generates the final research report from collected information | Both     |
| `WebSearch`        | Executes web searches to gather information                    | Both     |
| `ResearchSubtopic` | Conducts deep research on specific subtopics                   | Pro only |

### Research Flow Example

A typical streaming session follows this sequence:

1. **Planning** tool\_call → Initializing research plan
2. **Planning** tool\_response → Research plan initialized
3. **WebSearch** tool\_call → Executing search queries (with `queries` array)
4. **WebSearch** tool\_response → Search completed (with `sources` array)
5. *(Pro mode)* **ResearchSubtopic** tool\_call/response cycles for deeper research
6. **Generating** tool\_call → Generating final report
7. **Generating** tool\_response → Report generated
8. **Content** events → Streamed report chunks
9. **Sources** event → Complete list of all sources used
10. **Done** event → Stream complete

## Handling Streaming Responses

### Python Example

```python theme={null}
from tavily import TavilyClient

# Step 1. Instantiating your TavilyClient
tavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")

# Step 2. Creating a streaming research task
stream = tavily_client.research(
    input="Research the latest developments in AI",
    model="pro",
    stream=True
)

for chunk in stream:
    print(chunk.decode('utf-8'))
```

### JavaScript Example

```javascript theme={null}
const { tavily } = require("@tavily/core");

const tvly = tavily({ apiKey: "tvly-YOUR_API_KEY" });

const stream = await tvly.research("Research the latest developments in AI", {
  model: "pro",
  stream: true,
});

for await (const chunk of result as AsyncGenerator<Buffer, void, unknown>) {
    console.log(chunk.toString('utf-8'));
}
```

## Structured Output with Streaming

When using `output_schema` to request structured data, the `content` field will contain an object instead of a string:

```json theme={null}
{
  "delta": {
    "role": "assistant",
    "content": {
      "company": "Acme Corp",
      "key_metrics": ["Revenue: $1M", "Growth: 50%"],
      "summary": "Company showing strong growth..."
    }
  }
}
```

## Error Handling

If an error occurs during streaming, you may receive an error event:

```json theme={null}
{
  "id": "1d77bdf5-38a4-46c1-87a6-663dbc4528ec",
  "object": "error",
  "error": "An error occurred while streaming the research task"
}
```

Always implement proper error handling in your streaming client to gracefully handle these cases.

## Non-Streaming Alternative

If you don't need real-time updates, set `stream: false` (or omit the parameter) to receive a single complete response:

```json theme={null}
{
  "request_id": "123e4567-e89b-12d3-a456-426614174111",
  "created_at": "2025-01-15T10:30:00Z",
  "status": "pending",
  "input": "What are the latest developments in AI?",
  "model": "mini",
  "response_time": 1.23
}
```

You can then poll the status endpoint to check when the research is complete.


# Tavily Search
Source: https://docs.tavily.com/documentation/api-reference/endpoint/search

POST /search
Execute a search query using Tavily Search.



# Usage
Source: https://docs.tavily.com/documentation/api-reference/endpoint/usage

GET /usage
Get API key and account usage details



# Introduction
Source: https://docs.tavily.com/documentation/api-reference/introduction

Easily integrate our APIs with your services.

## Base URL

The base URL for all requests to the Tavily API is:

```plaintext theme={null}
https://api.tavily.com
```

## Authentication

All Tavily endpoints are authenticated using API keys.
[Get your free API key](https://app.tavily.com).

```bash theme={null}
curl -X POST https://api.tavily.com/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer tvly-YOUR_API_KEY" \
  -d '{"query": "Who is Leo Messi?"}'
```

## Endpoints

<CardGroup>
  <Card icon="magnifying-glass" href="/documentation/api-reference/endpoint/search">
    **`/search`**

    Tavily's powerful web search API.
  </Card>

  <Card icon="file-lines" href="/documentation/api-reference/endpoint/extract">
    **`/extract`**

    Tavily's powerful content extraction API.
  </Card>

  <Card icon="circle-nodes" href="/documentation/api-reference/endpoint/crawl">
    `/crawl` , `/map`

    Tavily's intelligent sitegraph navigation and extraction tools.
  </Card>

  <Card icon="book" href="/documentation/api-reference/endpoint/research">
    **`/research`**

    Tavily's comprehensive research API for in-depth analysis.
  </Card>
</CardGroup>

## Project Tracking

You can optionally attach a Project ID to your API requests to organize and track usage by project. This is useful when a single API key is used across multiple projects or applications.

To attach a project to your request, add the `X-Project-ID` header:

```bash theme={null}
curl -X POST https://api.tavily.com/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer tvly-YOUR_API_KEY" \
  -H "X-Project-ID: your-project-id" \
  -d '{"query": "Who is Leo Messi?"}'
```

**Key features:**

* An API key can be associated with multiple projects
* Filter requests by project in the [/logs endpoint](/documentation/api-reference/endpoint/usage) and platform usage dashboard
* Helps organize and track where requests originate from

<Note>
  When using the SDKs, you can specify a project using the `project_id`
  parameter when instantiating the client, or by setting the `TAVILY_PROJECT`
  environment variable.
</Note>

## Session Tracking

You can optionally include session and anonymized user identifiers in your API requests as HTTP headers. Tavily uses these identifiers for attribution and analytics across multi-step user interactions and agent workflows.

```bash theme={null}
curl -X POST https://api.tavily.com/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer tvly-YOUR_API_KEY" \
  -H "X-Session-Id: 5874812a-2e9b-43ea-8978-6cc9225b587b" \
  -H "X-Human-Id: h_4f9ac" \
  -d '{"query": "Who is Leo Messi?"}'
```

**Headers:**

* `X-Session-Id` — opaque identifier for a session of related requests. Lets you group multiple calls together (e.g. all requests from one user task or conversation).
* `X-Human-Id` — opaque identifier for the end-user behind the request. Useful when a single API key serves many human users — it helps Tavily better understand multi-step interactions and improve response quality. For security, Tavily hashes human IDs before processing or storing them.

<Note>
  When you use the Tavily MCP server or remote MCP server, `X-Session-Id` is
  populated automatically — you don't need to set it yourself. `X-Human-Id`
  can't be generated by the MCP server on its own, so it's only forwarded if
  your agent or developer provides it. See the
  [MCP documentation](/documentation/mcp) for details.
</Note>


# API Key Management
Source: https://docs.tavily.com/documentation/best-practices/api-key-management

Learn how to handle API key leaks and best practices for key rotation.

## What to do if your API key leaks

If you suspect or know that your API key has been leaked (e.g., committed to a public repository, shared in a screenshot, or exposed in client-side code), **immediate action is required** to protect your account and quota.

Follow these steps immediately:

1. **Log in to your account**: Go to the [Tavily Dashboard](https://app.tavily.com).
2. **Revoke the leaked key**: Navigate to the API Keys section. Identify the compromised key and delete or revoke it immediately. This will stop any unauthorized usage.
3. **Generate a new key**: Create a new API key to replace the compromised one.
4. **Update your applications**: Replace the old key with the new one in your environment variables, secrets management systems, and application code.

If you notice any unusual activity or usage spikes associated with the leaked key before you revoked it, please contact [support@tavily.com](mailto:support@tavily.com) for assistance.

## Rotating your API keys

As a general security best practice, we recommend rotating your API keys periodically (e.g., every 90 days). This minimizes the impact if a key is ever compromised without your knowledge.

### How to rotate your keys safely

To rotate your keys without downtime:

1. **Generate a new key**: Create a new API key in the [Tavily Dashboard](https://app.tavily.com) while keeping the old one active.
2. **Update your application**: Deploy your application with the new API key.
3. **Verify functionality**: Ensure your application is working correctly with the new key.
4. **Revoke the old key**: Once you are confirmed that the new key is in use and everything is functioning as expected, delete the old API key from the dashboard.

<Note>
  Never hardcode API keys in your source code. Always use environment variables or a secure secrets manager to store your credentials.
</Note>


# Best Practices for Crawl
Source: https://docs.tavily.com/documentation/best-practices/best-practices-crawl

Learn how to optimize crawl parameters, focus your crawls, and efficiently extract content from websites.

## Crawl vs Map

Understanding when to use each API:

| Feature                | Crawl                        | Map                      |
| ---------------------- | ---------------------------- | ------------------------ |
| **Content extraction** | Full content                 | URLs only                |
| **Use case**           | Deep content analysis        | Site structure discovery |
| **Speed**              | Slower (extracts content)    | Faster (URLs only)       |
| **Best for**           | RAG, analysis, documentation | Sitemap generation       |

### Use Crawl when you need:

* Full content extraction from pages
* Deep content analysis
* Processing of paginated or nested content
* Extraction of specific content patterns
* Integration with RAG systems

### Use Map when you need:

* Quick site structure discovery
* URL collection without content extraction
* Sitemap generation
* Path pattern matching
* Domain structure analysis

## Crawl Parameters

### Instructions

Guide the crawl with natural language to focus on relevant content:

```json theme={null}
{
  "url": "example.com",
  "max_depth": 2,
  "instructions": "Find all documentation pages about Python"
}
```

**When to use instructions:**

* To focus crawling on specific topics or content types
* When you need semantic filtering of pages
* For agentic use cases where relevance is critical

### Chunks per Source

Control the amount of content returned per page to prevent context window explosion:

```json theme={null}
{
  "url": "example.com",
  "instructions": "Find all documentation about authentication",
  "chunks_per_source": 3
}
```

**Key benefits:**

* Returns only relevant content snippets (max 500 characters each) instead of full page content
* Prevents context window from exploding in agentic use cases
* Chunks appear in `raw_content` as: `<chunk 1> [...] <chunk 2> [...] <chunk 3>`

> `chunks_per_source` is only available when instructions are provided.

### Depth and breadth

| Parameter     | Description                                     | Impact                     |
| ------------- | ----------------------------------------------- | -------------------------- |
| `max_depth`   | How many levels deep to crawl from starting URL | Exponential latency growth |
| `max_breadth` | Maximum links to follow per page                | Horizontal spread          |
| `limit`       | Total maximum pages to crawl                    | Hard cap on pages          |

**Performance tip:** Each level of depth increases crawl time exponentially. Start with `max_depth=1` and increase as needed.

```json theme={null}
// Conservative crawl
{
  "url": "example.com",
  "max_depth": 1,
  "max_breadth": 20,
  "limit": 20
}

// Comprehensive crawl
{
  "url": "example.com",
  "max_depth": 3,
  "max_breadth": 100,
  "limit": 500
}
```

## Filtering and Focusing

### Path patterns

Use regex patterns to include or exclude specific paths:

```json theme={null}
// Target specific sections
{
  "url": "example.com",
  "select_paths": ["/blog/.*", "/docs/.*", "/guides/.*"],
  "exclude_paths": ["/private/.*", "/admin/.*", "/test/.*"]
}

// Paginated content
{
  "url": "example.com/blog",
  "max_depth": 2,
  "select_paths": ["/blog/.*", "/blog/page/.*"],
  "exclude_paths": ["/blog/tag/.*"]
}
```

### Domain filtering

Control which domains to crawl:

```json theme={null}
// Stay within subdomain
{
  "url": "docs.example.com",
  "select_domains": ["^docs.example.com$"],
  "max_depth": 2
}

// Exclude specific domains
{
  "url": "example.com",
  "exclude_domains": ["^ads.example.com$", "^tracking.example.com$"],
  "max_depth": 2
}
```

### Extract depth

Controls extraction quality vs. speed.

| Depth             | When to use                            |
| ----------------- | -------------------------------------- |
| `basic` (default) | Simple content, faster processing      |
| `advanced`        | Complex pages, tables, structured data |

```json theme={null}
{
  "url": "docs.example.com",
  "max_depth": 2,
  "extract_depth": "advanced",
  "select_paths": ["/docs/.*"]
}
```

## Use Cases

### 1. Deep or Unlinked Content

Many sites have content that's difficult to access through standard means:

* Deeply nested pages not in main navigation
* Paginated archives (old blog posts, changelogs)
* Internal search-only content

**Best Practice:**

```json theme={null}
{
  "url": "example.com",
  "max_depth": 3,
  "max_breadth": 50,
  "limit": 200,
  "select_paths": ["/blog/.*", "/changelog/.*"],
  "exclude_paths": ["/private/.*", "/admin/.*"]
}
```

### 2. Structured but Nonstandard Layouts

For content that's structured but not marked up in schema.org:

* Documentation
* Changelogs
* FAQs

**Best Practice:**

```json theme={null}
{
  "url": "docs.example.com",
  "max_depth": 2,
  "extract_depth": "advanced",
  "select_paths": ["/docs/.*"]
}
```

### 3. Multi-modal Information Needs

When you need to combine information from multiple sections:

* Cross-referencing content
* Finding related information
* Building comprehensive knowledge bases

**Best Practice:**

```json theme={null}
{
  "url": "example.com",
  "max_depth": 2,
  "instructions": "Find all documentation pages that link to API reference docs",
  "extract_depth": "advanced"
}
```

### 4. Rapidly Changing Content

For content that updates frequently:

* API documentation
* Product announcements
* News sections

**Best Practice:**

```json theme={null}
{
  "url": "api.example.com",
  "max_depth": 1,
  "max_breadth": 100
}
```

### 5. Behind Auth / Paywalls

For content requiring authentication:

* Internal knowledge bases
* Customer help centers
* Gated documentation

**Best Practice:**

```json theme={null}
{
  "url": "help.example.com",
  "max_depth": 2,
  "select_domains": ["^help.example.com$"],
  "exclude_domains": ["^public.example.com$"]
}
```

### 6. Complete Coverage / Auditing

For comprehensive content analysis:

* Legal compliance checks
* Security audits
* Policy verification

**Best Practice:**

```json theme={null}
{
  "url": "example.com",
  "max_depth": 3,
  "max_breadth": 100,
  "limit": 1000,
  "extract_depth": "advanced",
  "instructions": "Find all mentions of GDPR and data protection policies"
}
```

### 7. Semantic Search or RAG Integration

For feeding content into LLMs or search systems:

* RAG systems
* Enterprise search
* Knowledge bases

**Best Practice:**

```json theme={null}
{
  "url": "docs.example.com",
  "max_depth": 2,
  "extract_depth": "advanced",
  "include_images": true
}
```

### 8. Known URL Patterns

When you have specific paths to crawl:

* Sitemap-based crawling
* Section-specific extraction
* Pattern-based content collection

**Best Practice:**

```json theme={null}
{
  "url": "example.com",
  "max_depth": 1,
  "select_paths": ["/docs/.*", "/api/.*", "/guides/.*"],
  "exclude_paths": ["/private/.*", "/admin/.*"]
}
```

## Performance Optimization

### Depth vs. Performance

* Each level of depth increases crawl time exponentially
* Start with max\_depth: 1 and increase as needed
* Use max\_breadth to control horizontal expansion
* Set appropriate limit to prevent excessive crawling

### Rate Limiting

* Respect site's robots.txt
* Implement appropriate delays between requests
* Monitor API usage and limits
* Use appropriate error handling for rate limits

## Integration with Map

Consider using Map before Crawl to:

1. Discover site structure
2. Identify relevant paths
3. Plan crawl strategy
4. Validate URL patterns

**Example workflow:**

1. Use Map to get site structure
2. Analyze paths and patterns
3. Configure Crawl with discovered paths
4. Execute focused crawl

**Benefits:**

* Discover site structure before crawling
* Identify relevant path patterns
* Avoid unnecessary crawling
* Validate URL patterns work correctly

## Common Pitfalls

### Excessive depth

* **Problem:** Setting `max_depth=4` or higher
* **Impact:** Exponential crawl time, unnecessary pages
* **Solution:** Start with 1-2 levels, increase only if needed

### Unfocused crawling

* **Problem:** No `instructions` provided, crawling entire site
* **Impact:** Wasted resources, irrelevant content, context explosion
* **Solution:** Use instructions to focus the crawl semantically

### Missing limits

* **Problem:** No `limit` parameter set
* **Impact:** Runaway crawls, unexpected costs
* **Solution:** Always set a reasonable `limit` value

### Ignoring failed results

* **Problem:** Not checking which pages failed extraction
* **Impact:** Incomplete data, missed content
* **Solution:** Monitor failed results and adjust parameters

## Use Session Tracking for Multi-Step Workflows

When an agent issues several Tavily calls to answer a single user task — for example, retrieving sources, then extracting full content from a subset, then running follow-up searches — pass a **consistent `session_id` across all related calls**.

If your agent serves multiple end-users behind a single API key, also pass a stable `human_id` per user. For security, Tavily hashes human IDs before processing or storing them.

See the [SDK references](/sdk/python/reference#session-tracking) or the [API HTTP headers](/documentation/api-reference/introduction#session--user-tracking) for how to set these.

## Summary

* Use instructions and chunks\_per\_source for focused, relevant results in agentic use cases
* Start with conservative parameters (`max_depth=1, max_breadth=20`)
* Use path patterns to focus crawling on relevant content
* Choose appropriate extract\_depth based on content complexity
* Set reasonable limits to prevent excessive crawling
* Monitor failed results and adjust patterns accordingly
* Use Map first to understand site structure
* Implement error handling for rate limits and failures
* Respect robots.txt and site policies
* Optimize for your use case (speed vs. completeness)
* Process results incrementally rather than waiting for full crawl
* Use `session_id` and `human_id` to link related calls across multi-step agent workflows

> Crawling is powerful but resource-intensive. Focus your crawls, start small, monitor results, and scale gradually based on actual needs.


# Best Practices for Extract
Source: https://docs.tavily.com/documentation/best-practices/best-practices-extract

Learn how to optimize content extraction, choose the right approach, and configure parameters for better performance.

## Extract Parameters

### Query

Use query to rerank extracted content chunks based on relevance:

```python theme={null}
await tavily_client.extract(
    urls=["https://example.com/article"],
    query="machine learning applications in healthcare"
)
```

**When to use query:**

* To extract only relevant portions of long documents
* When you need focused content instead of full page extraction
* For targeted information retrieval from specific URLs

> When `query` is provided, chunks are reranked based on relevance to the query.

### Chunks Per Source

Control the amount of content returned per URL to prevent context window explosion:

```python theme={null}
await tavily_client.extract(
    urls=["https://example.com/article"],
    query="machine learning applications in healthcare",
    chunks_per_source=3
)
```

**Key benefits:**

* Returns only relevant content snippets (max 500 characters each) instead of full page content
* Prevents context window from exploding
* Chunks appear in `raw_content` as: `<chunk 1> [...] <chunk 2> [...] <chunk 3>`
* Must be between 1 and 5 chunks per source

> `chunks_per_source` is only available when `query` is provided.

**Example with multiple URLs:**

```python theme={null}
await tavily_client.extract(
    urls=[
        "https://example.com/ml-healthcare",
        "https://example.com/ai-diagnostics",
        "https://example.com/medical-ai"
    ],
    query="AI diagnostic tools accuracy",
    chunks_per_source=2
)
```

This returns the 2 most relevant chunks from each URL, giving you focused, relevant content without overwhelming your context window.

## Extraction Approaches

### Search with include\_raw\_content

Enable include\_raw\_content=true in Search API calls to retrieve both search results and extracted content simultaneously.

```python theme={null}
response = await tavily_client.search(
    query="AI healthcare applications",
    include_raw_content=True,
    max_results=5
)
```

**When to use:**

* Quick prototyping
* Simple queries where search results are likely relevant
* Single API call convenience

### Direct Extract API

Use the Extract API when you want control over which specific URLs to extract from.

```python theme={null}
await tavily_client.extract(
    urls=["https://example.com/article1", "https://example.com/article2"],
    query="machine learning applications",
    chunks_per_source=3
)
```

**When to use:**

* You already have specific URLs to extract from
* You want to filter or curate URLs before extraction
* You need targeted extraction with query and chunks\_per\_source

**Key difference:** The main distinction is control, with Extract you choose exactly which URLs to extract from, while Search with `include_raw_content` extracts from all search results.

## Extract Depth

The `extract_depth` parameter controls extraction comprehensiveness:

| Depth             | Use case                                      |
| ----------------- | --------------------------------------------- |
| `basic` (default) | Simple text extraction, faster processing     |
| `advanced`        | Complex pages, tables, structured data, media |

### Using `extract_depth=advanced`

Best for content requiring detailed extraction:

```python theme={null}
await tavily_client.extract(
    url="https://example.com/complex-page",
    extract_depth="advanced"
)
```

**When to use advanced:**

* Dynamic content or JavaScript-rendered pages
* Tables and structured information
* Embedded media and rich content
* Higher extraction success rates needed

<Note>
  `extract_depth=advanced` provides better accuracy but increases latency and
  cost. Use `basic` for simple content.
</Note>

## Advanced Filtering Strategies

Beyond query-based filtering, consider these approaches for curating URLs before extraction:

| Strategy     | When to use                                    |
| ------------ | ---------------------------------------------- |
| Re-ranking   | Use dedicated re-ranking models for precision  |
| LLM-based    | Let an LLM assess relevance before extraction  |
| Clustering   | Group similar documents, extract from clusters |
| Domain-based | Filter by trusted domains before extracting    |
| Score-based  | Filter search results by relevance score       |

### Example: Score-based filtering

```python theme={null}
import asyncio
from tavily import AsyncTavilyClient

tavily_client = AsyncTavilyClient(api_key="tvly-YOUR_API_KEY")

async def filtered_extraction():
    # Search first
    response = await tavily_client.search(
        query="AI healthcare applications",
        search_depth="advanced",
        max_results=20
    )

    # Filter by relevance score (>0.5)
    relevant_urls = [
        result['url'] for result in response.get('results', [])
        if result.get('score', 0) > 0.5
    ]

    # Extract from filtered URLs with targeted query
    extracted_data = await tavily_client.extract(
        urls=relevant_urls,
        query="machine learning diagnostic tools",
        chunks_per_source=3,
        extract_depth="advanced"
    )

    return extracted_data

asyncio.run(filtered_extraction())
```

## Integration with Search

### Optimal workflow

* **Search** to discover relevant URLs
* **Filter** by relevance score, domain, or content snippet
* **Re-rank** if needed using specialized models
* **Extract** from top-ranked sources with query and chunks\_per\_source
* **Validate** extracted content quality
* **Process** for your RAG or AI application

### Example end-to-end pipeline

```python theme={null}
async def content_pipeline(topic):
    # 1. Search with sub-queries
    queries = generate_subqueries(topic)
    responses = await asyncio.gather(
        *[tavily_client.search(**q) for q in queries]
    )

    # 2. Filter and aggregate
    urls = []
    for response in responses:
        urls.extend([
            r['url'] for r in response['results']
            if r['score'] > 0.5
        ])

    # 3. Deduplicate
    urls = list(set(urls))[:20]  # Top 20 unique URLs

    # 4. Extract with error handling
    extracted = await asyncio.gather(
        *(tavily_client.extract(url, extract_depth="advanced") for url in urls),
        return_exceptions=True
    )

    # 5. Filter successful extractions
    return [e for e in extracted if not isinstance(e, Exception)]
```

## Use Session Tracking for Multi-Step Workflows

When an agent issues several Tavily calls to answer a single user task — for example, retrieving sources, then extracting full content from a subset, then running follow-up searches — pass a **consistent `session_id` across all related calls**.

If your agent serves multiple end-users behind a single API key, also pass a stable `human_id` per user. For security, Tavily hashes human IDs before processing or storing them.

See the [SDK references](/sdk/python/reference#session-tracking) or the [API HTTP headers](/documentation/api-reference/introduction#session--user-tracking) for how to set these.

## Summary

1. **Use query and chunks\_per\_source** for targeted, focused extraction
2. **Choose Extract API** when you need control over which URLs to extract from
3. **Filter URLs** before extraction using scores, re-ranking, or domain trust
4. **Choose appropriate extract\_depth** based on content complexity
5. **Process URLs concurrently** with async operations for better performance
6. **Implement error handling** to manage failed extractions gracefully
7. **Validate extracted content** before downstream processing
8. **Optimize costs** by extracting only necessary content with chunks\_per\_source
9. **Use `session_id` and `human_id`** to link related calls across multi-step agent workflows

> Start with query and chunks\_per\_source for targeted extraction. Filter URLs strategically, extract with appropriate depth, and handle errors gracefully for production-ready pipelines.


# Best Practices for Research
Source: https://docs.tavily.com/documentation/best-practices/best-practices-research

Learn how to write effective prompts, choose the right model, and configure output formats for better research results.

## Prompting

Define a **clear goal** with all **details** and **direction**.

* **Be specific when you can.** If you already know important details, include them (e.g., target market or industry, key competitors, customer segments, geography, or constraints).
* **Only stay open-ended if you don't know details and want discovery.** If you're exploring broadly, make that explicit (e.g., "tell me about the most impactful AI innovations in healthcare in 2025").
* **Avoid contradictions.** Don't include conflicting information, constraints, or goals in your prompt.
* **Share what's already known.** Include prior assumptions, existing decisions, or baseline knowledge—so the research doesn't repeat what you already have.
* **Keep the prompt clean and directed.** Use a clear task statement + essential context + desired output format. Avoid messy background dumps.

### Example Queries

```text theme={null}
"Research the company ____ and it's 2026 outlook. Provide a brief 
overview of the company, its products, services, and market position."
```

```text theme={null}
"Conduct a competitive analysis of ____ in 2026. Identify their main competitors, 
compare market positioning, and analyze key differentiators."
```

```text theme={null}
"We're evaluating Notion as a potential partner. We already know they primarily 
serve SMB and mid-market teams, expanded their AI features significantly in 2025, 
and most often compete with Confluence and ClickUp. Research Notion's 2026 outlook, 
including market position, growth risks, and where a partnership could be most 
valuable. Include citations."
```

## Model

| Model  | Best For                                                             |
| ------ | -------------------------------------------------------------------- |
| `pro`  | Comprehensive, multi-agent research for complex, multi-domain topics |
| `mini` | Targeted, efficient research for narrow or well-scoped questions     |
| `auto` | When you're unsure how complex research will be                      |

### Pro

Provides comprehensive, multi-agent research suited for complex topics that span multiple subtopics or domains. Use when you want deeper analysis, more thorough reports, or maximum accuracy.

```json theme={null}
{
  "input": "Analyze the competitive landscape for ____ in the SMB market, including key competitors, positioning, pricing models, customer segments, recent product moves, and where ____ has defensible advantages or risks over the next 2–3 years.",
  "model": "pro"
}
```

### Mini

Optimized for targeted, efficient research. Works best for narrow or well-scoped questions where you still benefit from agentic searching and synthesis, but don't need extensive depth.

```json theme={null}
{
  "input": "What are the top 5 competitors to ____ in the SMB market, and how do they differentiate?",
  "model": "mini"
}
```

## Structured Output vs. Report

* **Structured Output** - Best for data enrichment, pipelines, or powering UIs with specific fields.
* **Report** — Best for reading, sharing, or displaying verbatim (e.g., chat interfaces, briefs, newsletters).

### Formatting Your Schema

* **Write clear field descriptions.** In 1–3 sentences, say exactly what the field should contain and what to look for. This makes it easier for our models to interpret what you're looking for.
* **Match the structure you actually need.** Use the right types (arrays, objects, enums) instead of packing multiple values into one string (e.g., `competitors: string[]`, not `"A, B, C"`).
* **Avoid duplicate or overlapping fields.** Keep each field unique and specific - contradictions or redundancy can confuse our models.

## Streaming vs. Polling

<CardGroup>
  <Card title="Streaming" icon="wave-pulse" href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/research/streaming.ipynb">
    Best for user interfaces where you want real-time updates.
  </Card>

  <Card title="Polling" icon="rotate" href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/research/polling.ipynb">
    Best for background processes where you check status periodically.
  </Card>
</CardGroup>

<Tip>
  See streaming in action with the [live demo](https://chat-research.tavily.com/).
</Tip>

## Use Session Tracking for Multi-Step Workflows

When an agent issues several Tavily calls to answer a single user task — for example, retrieving sources, then extracting full content from a subset, then running follow-up searches — pass a **consistent `session_id` across all related calls**.

If your agent serves multiple end-users behind a single API key, also pass a stable `human_id` per user. For security, Tavily hashes human IDs before processing or storing them.

See the [SDK references](/sdk/python/reference#session-tracking) or the [API HTTP headers](/documentation/api-reference/introduction#session--user-tracking) for how to set these.


# Best Practices for Search
Source: https://docs.tavily.com/documentation/best-practices/best-practices-search

Learn how to optimize your queries, refine search filters, and leverage advanced parameters for better performance.

## Query Optimization

### Keep your query under 400 characters

Keep queries concise—under **400 characters**. Think of it as a query for an agent performing web search, not long-form prompts.

### Break complex queries into sub-queries

For complex or multi-topic queries, send separate focused requests:

```json theme={null}
// Instead of one massive query, break it down:
{ "query": "Competitors of company ABC." }
{ "query": "Financial performance of company ABC." }
{ "query": "Recent developments of company ABC." }
```

## Search Depth

The `search_depth` parameter controls the tradeoff between latency and relevance:

<Expandable title="Latency vs relevance chart">
  <img alt="Latency vs Relevance by Search Depth" />

  *This chart is a heuristic and is not to scale.*
</Expandable>

| Depth        | Latency | Relevance | Content Type |
| ------------ | ------- | --------- | ------------ |
| `ultra-fast` | Lowest  | Lower     | Content      |
| `fast`       | Low     | Good      | Chunks       |
| `basic`      | Medium  | High      | Content      |
| `advanced`   | Higher  | Highest   | Chunks       |

### Content types

| Type        | Description                                               |
| ----------- | --------------------------------------------------------- |
| **Content** | NLP-based summary of the page, providing general context  |
| **Chunks**  | Short snippets reranked by relevance to your search query |

Use **chunks** when you need highly targeted information aligned with your query. Use **content** when a general page summary is sufficient.

### Fast + Ultra-Fast

| Depth        | When to use                                                                                                                                                             |
| ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ultra-fast` | When latency is absolutely crucial. Delivers near-instant results, prioritizing speed over relevance. Ideal for real-time applications where response time is critical. |
| `fast`       | When latency is more important than relevance, but you want results in reranked chunks format. Good for applications that need quick, targeted snippets.                |
| `basic`      | A solid balance between relevance and latency. Best for general-purpose searches where you need quality results without the overhead of advanced processing.            |
| `advanced`   | When you need the highest relevance and are willing to trade off latency. Best for queries seeking specific, detailed information.                                      |

### Using `search_depth=advanced`

Best for queries seeking specific information:

```json theme={null}
{
  "query": "How many countries use Monday.com?",
  "search_depth": "advanced",
  "chunks_per_source": 3,
  "include_raw_content": true
}
```

## Filtering Results

### By date

| Parameter                 | Description                                             |
| ------------------------- | ------------------------------------------------------- |
| `time_range`              | Filter by relative time: `day`, `week`, `month`, `year` |
| `start_date` / `end_date` | Filter by specific date range (format: `YYYY-MM-DD`)    |

```json theme={null}
{ "query": "latest ML trends", "time_range": "month" }
{ "query": "AI news", "start_date": "2025-01-01", "end_date": "2025-02-01" }
```

### By topic

Use `topic` to filter by content type. Set to `news` for news sources (includes `published_date` metadata):

```json theme={null}
{ "query": "What happened today in NY?", "topic": "news" }
```

### By domain

| Parameter         | Description                           |
| ----------------- | ------------------------------------- |
| `include_domains` | Limit to specific domains             |
| `exclude_domains` | Filter out specific domains           |
| `country`         | Boost results from a specific country |

```json theme={null}
// Restrict to LinkedIn profiles
{ "query": "CEO background at Google", "include_domains": ["linkedin.com/in"] }

// Exclude irrelevant domains
{ "query": "US economy trends", "exclude_domains": ["espn.com", "vogue.com"] }

// Boost results from a country
{ "query": "tech startup funding", "country": "united states" }

// Wildcard: limit to .com, exclude specific site
{ "query": "AI news", "include_domains": ["*.com"], "exclude_domains": ["example.com"] }
```

<Note>Keep domain lists short and relevant for best results.</Note>

## Response Content

### `max_results`

Limits results returned (default: `5`). Setting too high may return lower-quality results.

### `include_raw_content`

Returns full extracted page content. For comprehensive extraction, consider a two-step process:

1. Search to retrieve relevant URLs
2. Use [Extract API](/documentation/best-practices/best-practices-extract#2-two-step-process-search-then-extract) to get content

### `auto_parameters`

Tavily automatically configures parameters based on query intent. Your explicit values override automatic ones.

```json theme={null}
{
  "query": "impact of AI in education policy",
  "auto_parameters": true,
  "search_depth": "basic" // Override to control cost
}
```

<Note>
  `auto_parameters` may set `search_depth` to `advanced` (2 credits). Set it
  manually to control cost.
</Note>

## Exact Match

Use `exact_match` only when searching for a specific name or phrase that must appear verbatim in the source content. Wrap the phrase in quotes within your query:

```json theme={null}
{
  "query": "\"John Smith\" CEO Acme Corp",
  "exact_match": true
}
```

Because this narrows retrieval, it may return fewer results or empty result fields when no exact matches are found. Best suited for:

* **Due diligence** — finding information on a specific person or entity
* **Data enrichment** — retrieving details about a known company or individual
* **Legal/compliance** — locating exact names or phrases in public records

## Async & Performance

Use async calls for concurrent requests:

```python theme={null}
import asyncio
from tavily import AsyncTavilyClient

tavily_client = AsyncTavilyClient("tvly-YOUR_API_KEY")

async def fetch_and_gather():
    queries = ["latest AI trends", "future of quantum computing"]
    responses = await asyncio.gather(
        *(tavily_client.search(q) for q in queries),
        return_exceptions=True
    )
    for response in responses:
        if isinstance(response, Exception):
            print(f"Failed: {response}")
        else:
            print(response)

asyncio.run(fetch_and_gather())
```

## Post-Processing

### Using metadata

Leverage response metadata to refine results:

| Field         | Use case                           |
| ------------- | ---------------------------------- |
| `score`       | Filter/rank by relevance score     |
| `title`       | Keyword filtering on headlines     |
| `content`     | Quick relevance check              |
| `raw_content` | Deep analysis and regex extraction |

### Score-based filtering

The `score` indicates relevance between query and content. Higher is better, but the ideal threshold depends on your use case.

```python theme={null}
# Filter results with score > 0.7
filtered = [r for r in results if r['score'] > 0.7]
```

### Regex extraction

Extract structured data from `raw_content`:

```python theme={null}
import re

# Extract location
text = "Company: Tavily, Location: New York"
match = re.search(r"Location: (\w+)", text)
location = match.group(1) if match else None  # "New York"

# Extract all emails
text = "Contact: john@example.com, support@tavily.com"
emails = re.findall(r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}", text)
```

## Use Session Tracking for Multi-Step Workflows

When an agent issues several Tavily calls to answer a single user task — for example, retrieving sources, then extracting full content from a subset, then running follow-up searches — pass a **consistent `session_id` across all related calls**.

If your agent serves multiple end-users behind a single API key, also pass a stable `human_id` per user. For security, Tavily hashes human IDs before processing or storing them.

See the [SDK references](/sdk/python/reference#session-tracking) or the [API HTTP headers](/documentation/api-reference/introduction#session--user-tracking) for how to set these.


# Deactivate Keys
Source: https://docs.tavily.com/documentation/enterprise/deactivate-keys

POST /deactivate-keys
Deactivate API keys either in bulk by `request_id` or individually.

**Option A — Deactivate by request ID:** Pass a `request_id` in the request body to deactivate all keys from that generation request.

**Option B — Deactivate individual key:** Set the key you want to deactivate in the `Authorization` header. No request body is required.

<Note>
  **Who can use this feature?**

  This feature is available on the Enterprise plan. [Talk to an expert](https://tavily.com/enterprise) to learn more.
</Note>


# Generate Keys
Source: https://docs.tavily.com/documentation/enterprise/generate-keys

POST /generate-keys
Generate one or more API keys with custom configuration.

<Note>
  **Who can use this feature?**

  This feature is available on the Enterprise plan. [Talk to an expert](https://tavily.com/enterprise) to learn more.
</Note>


# Key Info
Source: https://docs.tavily.com/documentation/enterprise/key-info

GET /key-info
Get information about an API key. The key to query is specified in the `Authorization` header.

<Note>
  **Who can use this feature?**

  This feature is available on the Enterprise plan. [Talk to an expert](https://tavily.com/enterprise) to learn more.
</Note>


# Organization Usage
Source: https://docs.tavily.com/documentation/enterprise/org-usage

POST /org-usage
Retrieve usage (credits), pay-as-you-go USD cost, and request counts for **every API key under an organization you own**, mirroring the platform's Usage analytics page.

Identify the organization by **name** in the request body. Authenticate with the organization owner's **personal API key** — the key from the owner's own personal account, **not** an organization or enterprise API key. Supports date-range, project, and depth filtering.

<Note>
  **Access to this API is an enterprise feature only.** [Talk to an expert](https://tavily.com/enterprise) to learn more.

  Authenticate with the organization **owner's personal API key** — the key from the owner's own **personal account**, *not* an organization or enterprise API key. Identify the organization by **name** in the request body.
</Note>


# Help Center
Source: https://docs.tavily.com/documentation/help





# OpenAI Agent Builder
Source: https://docs.tavily.com/documentation/integrations/agent-builder

Integrate OpenAI’s Agent Builder with Tavily’s MCP server to empower your AI agents with real-time web access.

## Getting Started

Before you begin, make sure you have:

* A [Tavily API key](https://app.tavily.com/home) (sign up for free if you don't have one)
* An OpenAI account with [organization verification](https://help.openai.com/en/articles/10910291-api-organization-verification)

<Step title="Create a new workflow in Agent Builder">
  Navigate to [Agent Builder](https://platform.openai.com/agent-builder) and click **Create New Workflow** to begin building your AI agent.

  <img alt="Create New Workflow" />
</Step>

<Step title="Select the agent node in your workflow">
  Click on the agent node in your workflow canvas to open the configuration panel.

  <img alt="Agent Block" />
</Step>

<Step title="Open the Tools configuration">
  In the configuration panel, locate and click on **Tools** in the sidebar to add external capabilities to your agent.

  <img alt="Tools Panel" />
</Step>

<Step title="Connect Tavily's MCP server">
  In the MCP configuration section, paste the Tavily MCP server URL:

  ```bash theme={null}
  https://mcp.tavily.com/mcp/?tavilyApiKey=YOUR_API_KEY
  ```

  Remember to replace `YOUR_API_KEY` with your actual Tavily API key.

  <Tip>
    Need an API key? Get one instantly from your [Tavily
    dashboard](https://app.tavily.com/home)
  </Tip>

  Click **Connect** to establish the connection to Tavily.

  <img alt="Tavily MCP Configuration" />
</Step>

<Step title="Enable Tavily capabilities for your agent">
  Once connected, you'll see Tavily's suite of tools available:

  * **tavily\_search** - Execute a search query.
  * **tavily\_extract** - Extract web page content from one or more specified URLs.
  * **tavily\_map** - Traverses websites like a graph and can explore hundreds of paths in parallel with intelligent discovery to generate comprehensive site maps.
  * **tavily\_crawl** - Traversal tool that can explore hundreds of paths in parallel with built-in extraction and intelligent discovery.

  Select the tools you want to activate for this agent, then click **Add** to integrate them.

  <img alt="Tavily Tools Available" />
</Step>

<Step title="Customize your agent's behavior">
  Now configure your agent:

  * **Name**: Choose a descriptive name for your agent
  * **Instructions**: Define the agent's role and how it should use Tavily's tools
  * **Reasoning**: Set the appropriate reasoning effort level
  * Click **Preview** to test the configuration

  **Sample instructions:**

  ```
  You are a research assistant that uses Tavily to search the web for up-to-date information.
  When the user asks questions that require current information, use Tavily to find relevant and recent sources.
  ```

  <img alt="Agent Configuration Panel" />
</Step>

<Step title="Verify your agent works correctly">
  Test your agent with queries that require real-time information to verify everything is working as expected.

  <img alt="Agent Testing Interface" />
</Step>

## Real-World Applications

### Market Research Agents

Build agents that continuously monitor industry trends, competitor activities, and market sentiment by searching for and analyzing relevant business information.

### Content Curation Systems

Create agents that automatically find, extract, and summarize content from multiple sources based on your specific criteria and preferences.

### Competitive Intelligence

Develop agents that crawl competitor websites, map their content strategies, and extract pricing, features, and positioning information.

### News & Event Monitors

Build agents that track breaking news on specific topics by leveraging Tavily's news search mode, providing real-time updates with citations.


# Agno
Source: https://docs.tavily.com/documentation/integrations/agno

Tavily is now available for integration through Agno.

## Introduction

Integrate [Tavily with Agno](https://docs.agno.com/tools/toolkits/search/tavily#tavily) to enhance your AI agents with powerful web search capabilities. Agno provides a lightweight library for building agents with memory, knowledge, tools, and reasoning, making it easy to incorporate real-time web search and data extraction into your AI applications.

## Step-by-Step Integration Guide

### Step 1: Install Required Packages

Install the necessary Python packages:

```bash theme={null}
pip install agno tavily-python
```

### Step 2: Set Up API Keys

* **Tavily API Key:** [Get your Tavily API key here](https://app.tavily.com/home)
* **OpenAI API Key:** [Get your OpenAI API key here](https://platform.openai.com/account/api-keys)

Set these as environment variables in your terminal or add them to your environment configuration file:

```bash theme={null}
export TAVILY_API_KEY=your_tavily_api_key
export OPENAI_API_KEY=your_openai_api_key
```

### Step 3: Initialize Agno Agent with Tavily Tools

```python theme={null}
from agno.agent import Agent
from agno.tools.tavily import TavilyTools
import os

# Initialize the agent with Tavily tools
agent = Agent(
    tools=[TavilyTools(
        search=True,                    # Enable search functionality
        max_tokens=8000,                # Increase max tokens for more detailed results
        search_depth="advanced",        # Use advanced search for comprehensive results
        format="markdown"               # Format results as markdown
    )],
    show_tool_calls=True
)
```

### Step 4: Example Use Cases

```python theme={null}
# Example 1: Basic search with default parameters
agent.print_response("Latest developments in quantum computing", markdown=True)

# Example 2: Market research with multiple parameters
agent.print_response(
    "Analyze the competitive landscape of AI-powered customer service solutions in 2024, "
    "focusing on market leaders and emerging trends",
    markdown=True
)

# Example 3: Technical documentation search
agent.print_response(
    "Find the latest documentation and tutorials about Python async programming, "
    "focusing on asyncio and FastAPI",
    markdown=True
)

# Example 4: News aggregation
agent.print_response(
    "Gather the latest news about artificial intelligence from tech news websites "
    "published in the last week",
    markdown=True
)
```

## Additional Use Cases

1. **Content Curation**: Gather and organize information from multiple sources
2. **Real-time Data Integration**: Keep your AI agents up-to-date with the latest information
3. **Technical Documentation**: Search and analyze technical documentation
4. **Market Analysis**: Conduct comprehensive market research and analysis


# Anthropic
Source: https://docs.tavily.com/documentation/integrations/anthropic

Integrate Tavily with Anthropic Claude to enhance your AI applications with real-time web search capabilities.

## Installation

Install the required packages:

```bash theme={null}
pip install anthropic tavily-python
```

## Setup

Set up your API keys:

```python theme={null}
import os
# Set your API keys
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
os.environ["TAVILY_API_KEY"] = "your-tavily-api-key"
```

## Using Tavily with Anthropic tool calling

```python theme={null}
import json
from anthropic import Anthropic
from tavily import TavilyClient

# Initialize clients
client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
MODEL_NAME = "claude-sonnet-4-20250514"
```

## Implementation

### System prompt

Define a system prompt to guide Claude's behavior:

```python theme={null}
SYSTEM_PROMPT = (
    "You are a research assistant. Use the tavily_search tool when needed. "
    "After tools run and tool results are provided back to you, produce a concise, well-structured summary "
    "with a short bullet list of key points and a 'Sources' section listing the URLs. "
)
```

### Tool schema

Define the Tavily search tool for Claude with enhanced parameters:

```python theme={null}
tools = [
    {
        "name": "tavily_search",
        "description": "Search the web using Tavily. Return relevant links & summaries.",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "Search query string."},
                "max_results": {"type": "integer", "default": 5},
                "search_depth": {"type": "string", "enum": ["basic", "advanced"]},
            },
            "required": ["query"]
        }
    }
]
```

[Scroll to the bottom to find the full json schema for search, extract, map and crawl](#tavily-endpoints-schema-for-anthropic-tool-definition)

### Tool execution

Create optimized functions to handle Tavily searches:

```python theme={null}
def tavily_search(**kwargs):
    return tavily_client.search(**kwargs)

def process_tool_call(name, args):
    if name == "tavily_search":
        return tavily_search(**args)
    raise ValueError(f"Unknown tool: {name}")
```

### Main chat function

The main function that handles the two-step conversation with Claude:

```python theme={null}
def chat_with_claude(user_message: str):
    print(f"\n{'='*50}\nUser Message: {user_message}\n{'='*50}")

    # ---- Call 1: allow tools so Claude can ask for searches ----
    initial_response = client.messages.create(
        model=MODEL_NAME,
        max_tokens=4096,
        system=SYSTEM_PROMPT,
        messages=[{"role": "user", "content": [{"type": "text", "text": user_message}]}],
        tools=tools,
    )

    print("\nInitial Response stop_reason:", initial_response.stop_reason)
    print("Initial content:", initial_response.content)

    # If Claude already answered in text, return it
    if initial_response.stop_reason != "tool_use":
        final_text = next((b.text for b in initial_response.content if getattr(b, "type", None) == "text"), None)
        print("\nFinal Response:", final_text)
        return final_text

    # ---- Execute ALL tool_use blocks from Call 1 ----
    tool_result_blocks = []
    for block in initial_response.content:
        if getattr(block, "type", None) == "tool_use":
            result = process_tool_call(block.name, block.input)
            tool_result_blocks.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": [{"type": "text", "text": json.dumps(result)}],
            })

    # ---- Call 2: NO tools; ask for the final summary from tool results ----
    final_response = client.messages.create(
        model=MODEL_NAME,
        max_tokens=4096,
        system=SYSTEM_PROMPT,
        messages=[
            {"role": "user", "content": [{"type": "text", "text": user_message}]},
            {"role": "assistant", "content": initial_response.content},    # Claude's tool requests
            {"role": "user", "content": tool_result_blocks},    # Your tool results
            {"role": "user", "content": [{"type": "text", "text":
                "Please synthesize the final answer now based on the tool results above. "
                "Include 3–7 bullets and a 'Sources' section with URLs."}]},
        ],
    )

    final_text = next((b.text for b in final_response.content if getattr(b, "type", None) == "text"), None)
    print("\nFinal Response:", final_text)
    return final_text
```

### Usage example

```python theme={null}
# Example usage
chat_with_claude("What is trending now in the agents space in 2025?")
```

<Accordion title="Full Code Example">
  ```python theme={null}
  import os
  import json
  from anthropic import Anthropic
  from tavily import TavilyClient

  client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
  tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
  MODEL_NAME = "claude-sonnet-4-20250514"

  SYSTEM_PROMPT = (
      "You are a research assistant. Use the tavily_search tool when needed. "
      "After tools run and tool results are provided back to you, produce a concise, well-structured summary "
      "with a short bullet list of key points and a 'Sources' section listing the URLs. "
  )

  # ---- Define your client-side tool schema for Anthropic ----
  tools = [
      {
          "name": "tavily_search",
          "description": "Search the web using Tavily. Return relevant links & summaries.",
          "input_schema": {
              "type": "object",
              "properties": {
                  "query": {"type": "string", "description": "Search query string."},
                  "max_results": {"type": "integer", "default": 5},
                  "search_depth": {"type": "string", "enum": ["basic", "advanced"]},
              },
              "required": ["query"]
          }
      }
  ]

  # ---- Your local tool executor ----
  def tavily_search(**kwargs):
      return tavily_client.search(**kwargs)

  def process_tool_call(name, args):
      if name == "tavily_search":
          return tavily_search(**args)
      raise ValueError(f"Unknown tool: {name}")

  def chat_with_claude(user_message: str):
      print(f"\n{'='*50}\nUser Message: {user_message}\n{'='*50}")

      # ---- Call 1: allow tools so Claude can ask for searches ----
      initial_response = client.messages.create(
          model=MODEL_NAME,
          max_tokens=4096,
          system=SYSTEM_PROMPT, 
          messages=[{"role": "user", "content": [{"type": "text", "text": user_message}]}],
          tools=tools,
      )

      print("\nInitial Response stop_reason:", initial_response.stop_reason)
      print("Initial content:", initial_response.content)

      # If Claude already answered in text, return it
      if initial_response.stop_reason != "tool_use":
          final_text = next((b.text for b in initial_response.content if getattr(b, "type", None) == "text"), None)
          print("\nFinal Response:", final_text)
          return final_text

      # ---- Execute ALL tool_use blocks from Call 1 ----
      tool_result_blocks = []
      for block in initial_response.content:
          if getattr(block, "type", None) == "tool_use":
              result = process_tool_call(block.name, block.input)
              tool_result_blocks.append({
                  "type": "tool_result",
                  "tool_use_id": block.id,
                  "content": [{"type": "text", "text": json.dumps(result)}],
              })

      # ---- Call 2: NO tools; ask for the final summary from tool results ----
      final_response = client.messages.create(
          model=MODEL_NAME,
          max_tokens=4096,
          system=SYSTEM_PROMPT,
          messages=[
              {"role": "user", "content": [{"type": "text", "text": user_message}]},
              {"role": "assistant", "content": initial_response.content},    # Claude's tool requests
              {"role": "user", "content": tool_result_blocks},    # Your tool results
              {"role": "user", "content": [{"type": "text", "text":
                  "Please synthesize the final answer now based on the tool results above. "
                  "Include 3–7 bullets and a 'Sources' section with URLs."}]},
          ],
      )

      final_text = next((b.text for b in final_response.content if getattr(b, "type", None) == "text"), None)
      print("\nFinal Response:", final_text)
      return final_text

  # Example usage
  chat_with_claude("What is trending now in the agents space in 2025?")
  ```
</Accordion>

## Tavily endpoints schema for Anthropic tool definition

> **Note:** When using these schemas, you can customize which parameters are exposed to the model based on your specific use case. For example, if you are building a finance application, you might set `topic`: `"finance"` for all queries without exposing the `topic` parameter. This way, the LLM can focus on deciding other parameters, such as `time_range`, `country`, and so on, based on the user's request. Feel free to modify these schemas as needed and only pass the parameters that are relevant to your application.

> **API Format:** The schemas below are for Anthropic's tool format. Each tool uses the `input_schema` structure with `type`, `properties`, and `required` fields.

<Accordion title="search schema">
  ```python theme={null}
  tools = [
      {
          "name": "tavily_search",
          "description": "A powerful web search tool that provides comprehensive, real-time results using Tavily's AI search engine. Returns relevant web content with customizable parameters for result count, content type, and domain filtering. Ideal for gathering current information, news, and detailed web content analysis.",
          "input_schema": {
              "type": "object",
              "required": ["query"],
              "properties": {
                  "query": {
                      "type": "string",
                      "description": "Search query"
                  },
                  "auto_parameters": {
                      "type": "boolean",
                      "default": False,
                      "description": "Auto-tune parameters based on the query. Explicit values you pass still win."
                  },
                  "topic": {
                      "type": "string",
                      "enum": ["general", "news","finance"],
                      "default": "general",
                      "description": "The category of the search. This will determine which of our agents will be used for the search"
                  },
                  "search_depth": {
                      "type": "string",
                      "enum": ["basic", "advanced"],
                      "default": "basic",
                      "description": "The depth of the search. It can be 'basic' or 'advanced'"
                  },
                  "chunks_per_source": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 3,
                      "default": 3,
                      "description": "Chunks are short content snippets (maximum 500 characters each) pulled directly from the source."
                  },
                  "max_results": {
                      "type": "integer",
                      "minimum": 0,
                      "maximum": 20,
                      "default": 5,
                      "description": "The maximum number of search results to return"
                  },
                  "time_range": {
                      "type": "string",
                      "enum": ["day", "week", "month", "year"],
                      "description": "The time range back from the current date to include in the search results. This feature is available for both 'general' and 'news' search topics"
                  },
                  "start_date": {
                      "type": "string",
                      "format": "date",
                      "description": "Will return all results after the specified start date. Required to be written in the format YYYY-MM-DD."
                  },
                  "end_date": {
                      "type": "string",
                      "format": "date",
                      "description": "Will return all results before the specified end date. Required to be written in the format YYYY-MM-DD"
                  },
                  "include_answer": {
                      "description": "Include an LLM-generated answer. 'basic' is brief; 'advanced' is more detailed.",
                      "oneOf": [
                          {"type": "boolean"},
                          {"type": "string", "enum": ["basic", "advanced"]}
                      ],
                      "default": False
                  },
                  "include_raw_content": {
                      "description": "Include the cleaned and parsed HTML content of each search result",
                      "oneOf": [
                          {"type": "boolean"},
                          {"type": "string", "enum": ["markdown", "text"]}
                      ],
                      "default": False
                  },
                  "include_images": {
                      "type": "boolean",
                      "default": False,
                      "description": "Include a list of query-related images in the response"
                  },
                  "include_image_descriptions": {
                      "type": "boolean",
                      "default": False,
                      "description": "Include a list of query-related images and their descriptions in the response"
                  },
                  "include_favicon": {
                      "type": "boolean",
                      "default": False,
                      "description": "Whether to include the favicon URL for each result"
                  },
                  "include_usage": {
                      "type": "boolean",
                      "default": False,
                      "description": "Whether to include credit usage information in the response"
                  },
                  "include_domains": {
                      "type": "array",
                      "items": {"type": "string"},
                      "maxItems": 300,
                      "description": "A list of domains to specifically include in the search results, if the user asks to search on specific sites set this to the domain of the site"
                  },
                  "exclude_domains": {
                      "type": "array",
                      "items": {"type": "string"},
                      "maxItems": 150,
                      "description": "List of domains to specifically exclude, if the user asks to exclude a domain set this to the domain of the site"
                  },
                  "country": {
                      "type": "string",
                      "enum": ["afghanistan", "albania", "algeria", "andorra", "angola", "argentina", "armenia", "australia", "austria", "azerbaijan", "bahamas", "bahrain", "bangladesh", "barbados", "belarus", "belgium", "belize", "benin", "bhutan", "bolivia", "bosnia and herzegovina", "botswana", "brazil", "brunei", "bulgaria", "burkina faso", "burundi", "cambodia", "cameroon", "canada", "cape verde", "central african republic", "chad", "chile", "china", "colombia", "comoros", "congo", "costa rica", "croatia", "cuba", "cyprus", "czech republic", "denmark", "djibouti", "dominican republic", "ecuador", "egypt", "el salvador", "equatorial guinea", "eritrea", "estonia", "ethiopia", "fiji", "finland", "france", "gabon", "gambia", "georgia", "germany", "ghana", "greece", "guatemala", "guinea", "haiti", "honduras", "hungary", "iceland", "india", "indonesia", "iran", "iraq", "ireland", "israel", "italy", "jamaica", "japan", "jordan", "kazakhstan", "kenya", "kuwait", "kyrgyzstan", "latvia", "lebanon", "lesotho", "liberia", "libya", "liechtenstein", "lithuania", "luxembourg", "madagascar", "malawi", "malaysia", "maldives", "mali", "malta", "mauritania", "mauritius", "mexico", "moldova", "monaco", "mongolia", "montenegro", "morocco", "mozambique", "myanmar", "namibia", "nepal", "netherlands", "new zealand", "nicaragua", "niger", "nigeria", "north korea", "north macedonia", "norway", "oman", "pakistan", "panama", "papua new guinea", "paraguay", "peru", "philippines", "poland", "portugal", "qatar", "romania", "russia", "rwanda", "saudi arabia", "senegal", "serbia", "singapore", "slovakia", "slovenia", "somalia", "south africa", "south korea", "south sudan", "spain", "sri lanka", "sudan", "sweden", "switzerland", "syria", "taiwan", "tajikistan", "tanzania", "thailand", "togo", "trinidad and tobago", "tunisia", "turkey", "turkmenistan", "uganda", "ukraine", "united arab emirates", "united kingdom", "united states", "uruguay", "uzbekistan", "venezuela", "vietnam", "yemen", "zambia", "zimbabwe"],
                      "description": "Boost search results from a specific country. This will prioritize content from the selected country in the search results. Available only if topic is general. Country names MUST be written in lowercase, plain English, with spaces and no underscores."
                  }
              }
          }
      }
  ]
  ```
</Accordion>

<Accordion title="extract schema">
  ```python theme={null}
  tools = [
      {
          "name": "tavily_extract",
          "description": "A powerful web content extraction tool that retrieves and processes raw content from specified URLs, ideal for data collection, content analysis, and research tasks.",
          "input_schema": {
              "type": "object",
              "required": ["urls"],
              "properties": {
                  "urls": {
                      "type": "string",
                      "description": "List of URLs to extract content from"
                  },
                  "include_images": {
                      "type": "boolean",
                      "default": False,
                      "description": "Include a list of images extracted from the urls in the response"
                  },
                  "include_favicon": {
                      "type": "boolean",
                      "default": False,
                      "description": "Whether to include the favicon URL for each result"
                  },
                  "include_usage": {
                      "type": "boolean",
                      "default": False,
                      "description": "Whether to include credit usage information in the response"
                  },
                  "extract_depth": {
                      "type": "string",
                      "enum": ["basic", "advanced"],
                      "default": "basic",
                      "description": "Depth of extraction - 'basic' or 'advanced', if urls are linkedin use 'advanced' or if explicitly told to use advanced"
                  },
                  "timeout": {
                      "type": "number",
                      "enum": ["basic", "advanced"],
                      "minimum": 0,
                      "maximum": 60,
                      "default": None,
                      "description": "Maximum time in seconds to wait for the URL extraction before timing out. Must be between 1.0 and 60.0 seconds. If not specified, default timeouts are applied based on extract_depth: 10 seconds for basic extraction and 30 seconds for advanced extraction"
                  },
                  "format": {
                      "type": "string",
                      "enum": ["markdown", "text"],
                      "default": "markdown",
                      "description": "The format of the extracted web page content. markdown returns content in markdown format. text returns plain text and may increase latency."
                  }
              }
          }
      }
  ]
  ```
</Accordion>

<Accordion title="map schema">
  ```python theme={null}
  tools = [
      {
          "name": "tavily_map",
          "description": "A powerful web mapping tool that creates a structured map of website URLs, allowing you to discover and analyze site structure, content organization, and navigation paths. Perfect for site audits, content discovery, and understanding website architecture.",
          "input_schema": {
              "type": "object",
              "required": ["url"],
              "properties": {
                  "url": {
                      "type": "string",
                      "description": "The root URL to begin the mapping"
                  },
                  "instructions": {
                      "type": "string",
                      "description": "Natural language instructions for the crawler"
                  },
                  "max_depth": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 5,
                      "default": 1,
                      "description": "Max depth of the mapping. Defines how far from the base URL the crawler can explore"
                  },
                  "max_breadth": {
                      "type": "integer",
                      "minimum": 1,
                      "default": 20,
                      "description": "Max number of links to follow per level of the tree (i.e., per page)"
                  },
                  "limit": {
                      "type": "integer",
                      "minimum": 1,
                      "default": 50,
                      "description": "Total number of links the crawler will process before stopping"
                  },
                  "select_paths": {
                      "type": "array",
                      "items": {"type": "string"},
                      "description": "Regex patterns to select only URLs with specific path patterns (e.g., /docs/.*, /api/v1.*)"
                  },
                  "select_domains": {
                      "type": "array",
                      "items": {"type": "string"},
                      "description": "Regex patterns to select crawling to specific domains or subdomains (e.g., ^docs\\.example\\.com$)"
                  },
                  "exclude_paths": {
                      "type": "array",
                      "items": {"type": "string"},
                      "description": "Regex patterns to exclude URLs with specific path patterns (e.g., /admin/.*)."
                  },
                  "exclude_domains": {
                      "type": "array",
                      "items": {"type": "string"},
                      "description": "Regex patterns to exclude specific domains or subdomains"
                  },
                  "allow_external": {
                      "type": "boolean",
                      "default": True,
                      "description": "Whether to allow following links that go to external domains"
                  },
                  "categories": {
                      "type": "array",
                      "items": {
                          "type": "string",
                          "enum": ["Documentation", "Blog", "Careers","About","Pricing","Community","Developers","Contact","Media"]
                      },
                      "description": "Filter URLs using predefined categories like documentation, blog, api, etc"
                  },
                  "include_usage": {
                      "type": "boolean",
                      "default": False,
                      "description": "Whether to include credit usage information in the response"
                  }
              }
          }
      }
  ]
  ```
</Accordion>

<Accordion title="crawl schema">
  ```python theme={null}
  tools = [
      {
          "name": "tavily_crawl",
          "description": "A powerful web crawler that initiates a structured web crawl starting from a specified base URL. The crawler expands from that point like a tree, following internal links across pages. You can control how deep and wide it goes, and guide it to focus on specific sections of the site.",
          "input_schema": {
              "type": "object",
              "required": ["url"],
              "properties": {
                  "url": {
                      "type": "string",
                      "description": "The root URL to begin the crawl"
                  },
                  "instructions": {
                      "type": "string",
                      "description": "Natural language instructions for the crawler"
                  },
                  "max_depth": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum: 5,
                      "default": 1,
                      "description": "Max depth of the crawl. Defines how far from the base URL the crawler can explore."
                  },
                  "max_breadth": {
                      "type": "integer",
                      "minimum": 1,
                      "default": 20,
                      "description": "Max number of links to follow per level of the tree (i.e., per page)"
                  },
                  "limit": {
                      "type": "integer",
                      "minimum": 1,
                      "default": 50,
                      "description": "Total number of links the crawler will process before stopping"
                  },
                  "select_paths": {
                      "type": "array",
                      "items": {"type": "string"},
                      "description": "Regex patterns to select only URLs with specific path patterns (e.g., /docs/.*, /api/v1.*)"
                  },
                  "select_domains": {
                      "type": "array",
                      "items": {"type": "string"},
                      "description": "Regex patterns to select crawling to specific domains or subdomains (e.g., ^docs\\.example\\.com$)"
                  },
                  "exclude_paths": {
                      "type": "array",
                      "items": {"type": "string"},
                      "description": "Regex patterns to exclude paths (e.g., /private/.*, /admin/.*)"
                  },
                  "exclude_domains": {
                      "type": "array",
                      "items": {"type": "string"},
                      "description": "Regex patterns to exclude domains/subdomains (e.g., ^private\\.example\\.com$)"
                  },
                  "allow_external": {
                      "type": "boolean",
                      "default": True,
                      "description": "Whether to allow following links that go to external domains"
                  },
                  "include_images": {
                      "type": "boolean",
                      "default": False,
                      "description": "Include images discovered during the crawl"
                  },
                  "categories": {
                      "type": "array",
                      "items": {
                          "type": "string",
                          "enum": ["Careers", "Blog", "Documentation", "About", "Pricing", "Community", "Developers", "Contact", "Media"]
                      },
                      "description": "Filter URLs using predefined categories like documentation, blog, api, etc"
                  },
                  "extract_depth": {
                      "type": "string",
                      "enum": ["basic", "advanced"],
                      "default": "basic",
                      "description": "Advanced extraction retrieves more data, including tables and embedded content, with higher success but may increase latency"
                  },
                  "format": {
                      "type": "string",
                      "enum": ["markdown", "text"],
                      "default": "markdown",
                      "description": "The format of the extracted web page content. markdown returns content in markdown format. text returns plain text and may increase latency."
                  },
                  "include_favicon": {
                      "type": "boolean",
                      "default": False,
                      "description": "Whether to include the favicon URL for each result"
                  },
                  "include_usage": {
                      "type": "boolean",
                      "default": False,
                      "description": "Whether to include credit usage information in the response"
                  }
              }
          }
      }
  ]
  ```
</Accordion>

For more information about Tavily's capabilities, check out our [API documentation](/documentation/api-reference/introduction) and [best practices](/documentation/best-practices/best-practices-search).


# Arcade.dev
Source: https://docs.tavily.com/documentation/integrations/arcade-dev

Connect Tavily to Arcade.dev MCP Gateway for governed web search, extraction, crawling, mapping, and research.

<Frame>
  <img alt="Tavily on Arcade" />
</Frame>

## Overview

[Arcade.dev](https://www.arcade.dev/) is an MCP runtime platform for connecting agents to MCP servers through a managed **MCP Gateway**. Tavily is available as a [verified partner MCP server on Arcade](https://www.arcade.dev/tools/tavily), so you can register Tavily's remote MCP server once and expose its web intelligence tools through Arcade.dev to all of your agents.

Use this integration when you want Tavily behind the same Arcade gateway as your other tools. Your agent connects to Arcade, Arcade routes Tavily tool calls to the Tavily MCP server, and Arcade applies its gateway controls across the full tool stack.

## How it works

1. Generate a Tavily MCP server URL with your Tavily API key.
2. Add that URL to Arcade as a **Remote MCP** server.
3. Add Tavily to an Arcade **MCP Gateway** with any other servers your agent needs.
4. Connect your MCP client or agent framework to the Arcade gateway URL.

This gives your agent one MCP endpoint for Tavily, plus other tools such as Google Docs, Slack, GitHub, etc., while Arcade handles gateway-level authorization, access control, and audit logging.

## Available Tools

After Tavily is registered in Arcade, your agent can call these tools through the gateway:

| Tool              | Description                                        |
| ----------------- | -------------------------------------------------- |
| `Tavily.Search`   | Real-time web search with agent-optimized ranking. |
| `Tavily.Extract`  | Extract structured content from specific URLs.     |
| `Tavily.Crawl`    | Crawl a site and return content across pages.      |
| `Tavily.Map`      | Map the structure of a site or domain.             |
| `Tavily.Research` | Multi-source deep research across the web.         |

## Prerequisites

* An [Arcade.dev account](https://www.arcade.dev/) with access to the Dashboard.
* A [Tavily API key](https://app.tavily.com/home).

## Setup

<Steps>
  <Step title="Generate your Tavily MCP URL">
    In the [Tavily dashboard](https://app.tavily.com/home), go to **Overview** → **Remote MCP** and copy the generated URL. It should use this format:

    ```
    https://mcp.tavily.com/mcp/?tavilyApiKey=YOUR_API_KEY
    ```

    Treat this URL as a secret because it contains your Tavily API key. See the [Tavily MCP documentation](/documentation/mcp) for additional configuration options.
  </Step>

  <Step title="Add Tavily as a remote MCP server in Arcade">
    In the [Arcade Dashboard](https://api.arcade.dev/dashboard), go to **Servers** → **Add Server** → **Remote MCP**. Paste the Tavily MCP URL from the previous step and save.

    Refer to the [Arcade Tavily integration documentation](https://docs.arcade.dev/en/resources/integrations/search/tavily) for the full walkthrough and to [Add remote MCP servers](https://docs.arcade.dev/guides/mcp-gateways/add-remote-servers) for advanced settings such as retries, OAuth, and custom headers.
  </Step>

  <Step title="Verify the Tavily tools">
    Arcade discovers the Tavily tools automatically after registration. Confirm that `Tavily.Search`, `Tavily.Extract`, `Tavily.Crawl`, `Tavily.Map`, and `Tavily.Research` appear in the Arcade Playground and in the MCP Gateway tool picker.
  </Step>

  <Step title="Create an MCP Gateway">
    Go to **MCP Gateways** → **Create Gateway** and select Tavily plus any other MCP servers your agent needs, such as Google Docs, Slack, Salesforce, or GitHub.

    Set the authentication mode to **Arcade Auth** when you want users to authenticate with their Arcade account and have Arcade apply gateway-level controls at runtime.
  </Step>

  <Step title="Connect your agent to the gateway">
    Once the gateway is published, Arcade gives you a single Streamable HTTP URL of the form:

    ```
    https://api.arcade.dev/mcp/<YOUR-GATEWAY-SLUG>
    ```

    Point any MCP-compatible client at this URL, including **Cursor**, **Claude Desktop**, **Codex**, **VS Code**, or any other application.
  </Step>
</Steps>

## Example workflow

An agent connected to your Arcade gateway can use Tavily to research a topic, extract source content, and then call other Arcade tools to turn that research into action. For example, the agent can:

* Call `Tavily.Search` to find current sources.
* Call `Tavily.Extract` to read the most relevant pages.
* Draft findings into Google Docs or send a summary to Slack through the same Arcade gateway.

## Benefits of Tavily + Arcade

* **Centralized governance:** Authorization, user authentication, access control, and audit logging are handled uniformly by Arcade's runtime across Tavily and every other server in the gateway.
* **Composable tool stacks:** Pair Tavily's web research tools with Arcade's productivity, communications, and CRM integrations behind one MCP endpoint.
* **Simple client configuration:** MCP-compatible clients connect to the Arcade gateway URL instead of configuring Tavily separately in every client.

## Resources

* [Arcade Tavily integration docs](https://docs.arcade.dev/en/resources/integrations/search/tavily)
* [Tavily on Arcade Tools](https://www.arcade.dev/tools/tavily)
* [Tavily MCP Documentation](/documentation/mcp)


# Cartesia
Source: https://docs.tavily.com/documentation/integrations/cartesia

Build real-time voice agents that search and extract web content with Tavily and the Cartesia Line SDK.

## Introduction

[Cartesia Line](https://docs.cartesia.ai/line/introduction) is an SDK for building low-latency voice agents. Pairing Line with Tavily gives your voice agent live web access — use [Tavily Search](https://docs.tavily.com/documentation/api-reference/endpoint/search) for fast, voice-friendly lookups and [Tavily Extract](https://docs.tavily.com/documentation/api-reference/endpoint/extract) for deep-dives into specific pages.

A complete reference implementation lives in the [Cartesia Line repo](https://github.com/cartesia-ai/line/tree/main/example_integrations/tavily).

## Step-by-Step Integration Guide

### Step 1: Install Required Packages

```bash theme={null}
uv venv
uv add cartesia-line tavily-python loguru python-dotenv
```

### Step 2: Set Up API Keys

* **Tavily API Key:** [Get your Tavily API key here](https://app.tavily.com/home)
* **OpenAI API Key:** [Get your OpenAI API key here](https://platform.openai.com/account/api-keys)

Create a `.env` file:

```bash theme={null}
TAVILY_API_KEY=tvly-your-api-key
OPENAI_API_KEY=your-openai-api-key
```

### Step 3: Define Tavily Tools

Wrap Tavily's `AsyncTavilyClient` in two `@loopback_tool` functions so the voice agent can call them mid-conversation. Reusing a single `AsyncTavilyClient` across calls keeps the underlying HTTP session warm, which matters for latency on a live call.

```python theme={null}
from typing import Annotated, Optional

from loguru import logger
from tavily import AsyncTavilyClient

from line.llm_agent import ToolEnv, loopback_tool

EXTRACT_MAX_CHARS = 3000


class TavilyTools:
    def __init__(self, api_key: str):
        self._client = AsyncTavilyClient(
            api_key=api_key,
            client_source="cartesia-line-agent",
        )

    @loopback_tool
    async def web_search(
        self,
        ctx: ToolEnv,
        query: Annotated[str, "The search query. Be specific and include key terms."],
        time_range: Annotated[
            Optional[str],
            "Optional time filter: 'day', 'week', 'month', or 'year'.",
        ] = None,
    ) -> str:
        """Search the web for current information."""
        kwargs: dict = {"query": query, "search_depth": "fast", "max_results": 5}
        if time_range is not None:
            kwargs["time_range"] = time_range

        response = await self._client.search(**kwargs)
        results = response.get("results", [])
        if not results:
            return "No relevant information found."

        parts = [f"Search Results for: '{query}'\n"]
        for i, result in enumerate(results):
            score = result.get("score", 0)
            parts.append(f"\n--- Source {i + 1}: {result['title']} (relevance: {score:.2f}) ---\n")
            if result.get("content"):
                parts.append(f"{result['content']}\n")
            parts.append(f"URL: {result['url']}\n")
        return "".join(parts)

    @loopback_tool
    async def web_extract(
        self,
        ctx: ToolEnv,
        url: Annotated[str, "The URL to extract content from."],
    ) -> str:
        """Extract the full content of a webpage given its URL."""
        response = await self._client.extract(urls=[url])
        results = response.get("results", [])
        if not results:
            failed = response.get("failed_results", [])
            if failed:
                return f"Extraction failed for {url}: {failed[0].get('error', 'unknown error')}"
            return "No content could be extracted from that URL."

        raw_content = results[0].get("raw_content", "")
        if not raw_content:
            return "The page was reached but no readable content was found."
        if len(raw_content) > EXTRACT_MAX_CHARS:
            raw_content = raw_content[:EXTRACT_MAX_CHARS] + "\n\n[Content truncated]"
        return f"Extracted content from {url}:\n\n{raw_content}"
```

### Step 4: Wire the Tools into a Voice Agent

```python theme={null}
import os
from datetime import datetime

from line.llm_agent import LlmAgent, LlmConfig, end_call
from line.voice_agent_app import AgentEnv, CallRequest, VoiceAgentApp

SYSTEM_PROMPT = """Today is {today}. You are a fast research assistant on a live voice call.

Use `web_search` for current events, facts, prices, or anything that needs fresh data.
Use `web_extract` only when a search snippet is too thin — pass it a URL from a prior search.

Lead with the answer. Keep replies to two or three sentences unless asked for more.
This is a voice call: speak in plain sentences, no markdown, no lists, no special characters."""


async def get_agent(env: AgentEnv, call_request: CallRequest):
    api_key = os.environ["TAVILY_API_KEY"]
    tavily = TavilyTools(api_key=api_key)

    return LlmAgent(
        model="openai/gpt-5.4-mini",
        api_key=os.environ["OPENAI_API_KEY"],
        tools=[tavily.web_search, tavily.web_extract, end_call],
        config=LlmConfig(
            system_prompt=SYSTEM_PROMPT.format(today=datetime.now().strftime("%Y-%m-%d")),
            introduction="Hey! I'm your research assistant. Ask me anything.",
            max_tokens=600,
            temperature=0.7,
        ),
    )


app = VoiceAgentApp(get_agent=get_agent)

if __name__ == "__main__":
    app.run()
```

<Note>
  Ensure you have the Cartesia CLI installed. Please refer to the [Cartesia CLI documentation](https://docs.cartesia.ai/line/cli) for more information.
</Note>

Run the agent and connect to it:

```bash theme={null}
uv run main.py
# in another terminal
cartesia chat 8000
```

## Choosing a Search Depth

Voice agents are latency-sensitive. Tavily exposes four search depths — for live calls, we recommend using `fast` or `ultra-fast`.

| Depth        | Latency | Content Type            | Cost      | Best For                             |
| ------------ | ------- | ----------------------- | --------- | ------------------------------------ |
| `ultra-fast` | Lowest  | NLP summary per URL     | 1 credit  | Voice agents, real-time chat         |
| `fast`       | Low     | Reranked chunks per URL | 1 credit  | Chunk-based results with low latency |
| `basic`      | Medium  | NLP summary per URL     | 1 credit  | General-purpose search               |
| `advanced`   | Higher  | Reranked chunks per URL | 2 credits | Precision-critical queries           |

## Additional Parameters

Extend `web_search` with any of Tavily's search parameters:

* `time_range` — `"day"`, `"week"`, `"month"`, or `"year"` for recency filtering
* `include_domains` / `exclude_domains` — restrict or block specific sources
* `include_answer` — `"basic"` or `"advanced"` for an LLM-generated answer alongside results

See the [Search API reference](https://docs.tavily.com/documentation/api-reference/endpoint/search) and the [Python SDK reference](https://docs.tavily.com/sdk/python/reference) for the full parameter list.

For `web_extract`, the most useful knobs are:

* `extract_depth` — `"basic"` (default) or `"advanced"` for tables and embedded content
* `format` — `"markdown"` (default) or `"text"`

See the [Extract API reference](https://docs.tavily.com/documentation/api-reference/endpoint/extract) for more.

## Benefits of Tavily + Cartesia

* **Voice-optimized latency:** `fast` and `ultra-fast` search depths keep round-trips short enough for live conversation.
* **Fresh context:** Voice agents can answer questions about today's news, prices, and events without retraining.
* **Targeted deep-dives:** Providing URLs to `web_extract` allows the agent to pull full-page content when a snippet isn't enough.


# Claude
Source: https://docs.tavily.com/documentation/integrations/claude

Use Tavily across the Claude ecosystem as a Connector or as a Plugin to enable real-time web search, extraction, crawling, and research.

## Introduction

[Claude](https://claude.ai/) is Anthropic's AI assistant designed for reasoning, coding, and research workflows across multiple environments like Claude Desktop, claude.ai, Claude Code, and Claude Cowork.

Tavily integrates with the Claude ecosystem in **two main ways**:

* **As a Connector** — a one-click, OAuth-based integration available in Claude Desktop, claude.ai, and Claude Cowork. Built on top of [MCP](https://modelcontextprotocol.io/docs/getting-started/intro) (Model Context Protocol).
* **As a Plugin** — a packaged installation for Claude Code that bundles Tavily's tools and slash commands directly into your terminal workflow.

### Connector vs. Plugin

|                    | **Connector**                                 | **Plugin**                                                        |
| ------------------ | --------------------------------------------- | ----------------------------------------------------------------- |
| **Where it runs**  | Claude Desktop, claude.ai, Claude Cowork      | Claude Code (terminal), Claude Cowork (desktop)                   |
| **Install method** | One-click + OAuth in Claude Settings          | `/plugin install tavily` (CLI) or **Add Plugins** in Cowork       |
| **Auth**           | OAuth flow                                    | `TAVILY_API_KEY` in `~/.claude/settings.json`                     |
| **Best for**       | Chat-based research, everyday Claude usage    | Developer workflows, scripted research, slash-command power users |
| **Invocation**     | Automatic — Claude picks the tool when needed | Automatic or via slash commands (e.g., `/tavily:search`)          |

Pick whichever matches where you use Claude — or use both.

***

# Connector

## Tavily + Claude

Tavily integrates with Claude as an official connector, giving Claude access to:

* Real-time web search
* Content extraction from URLs
* Website crawling and mapping
* Deep research workflows

Once connected, Claude can automatically use Tavily whenever external information is required.

***

## Supported Claude surfaces

Tavily works across the Claude ecosystem:

* [Claude Cowork](https://www.anthropic.com/product/claude-cowork)
* Claude Code - Through Claude Desktop, Alternatively if you want to use Tavily through Claude Code terminal, follow [this](https://docs.tavily.com/documentation/mcp#connect-to-claude-code).
* [claude.ai](https://claude.ai/)
* [Claude Desktop](https://support.claude.com/en/articles/10065433-installing-claude-desktop)

***

## Installation

<Frame>
  <img alt="Onboarding Tavily Connector on Claude" />
</Frame>

<AccordionGroup>
  <Accordion title="Step 1: Open Claude settings">
    Go to **Settings** inside Claude.
  </Accordion>

  <Accordion title="Step 2: Navigate to Connectors">
    Click on the **Connectors** tab.
  </Accordion>

  <Accordion title="Step 3: Add Tavily">
    Search for **Tavily** and click the **+ (Connect)** button.
  </Accordion>

  <Accordion title="Step 4: Authenticate via OAuth">
    Complete the OAuth flow to connect Tavily.
  </Accordion>

  <Accordion title="Step 5: Configure permissions">
    After connecting, go to **Configure** and enable **Allow always** (recommended).

    This allows Claude to automatically use Tavily whenever web search or external data is needed.
  </Accordion>
</AccordionGroup>

***

## Tavily tools available

| Tool             | Description                           |
| ---------------- | ------------------------------------- |
| tavily\_search   | Real-time web search                  |
| tavily\_extract  | Extract clean content from URLs       |
| tavily\_crawl    | Crawl multiple pages from a site      |
| tavily\_map      | Discover site structure and URLs      |
| tavily\_research | Multi-step deep research workflows    |
| tavily\_skill    | Search the best skills for your agent |

***

## How Tavily works inside Claude

Once connected, Tavily runs automatically inside Claude:

* Claude detects when external data or web search is needed
* Tavily tools are invoked automatically
* Results are returned and used in Claude's response

If **Allow always** is enabled, everything works seamlessly without the need of manually accepting it.

***

## Example use cases

### tavily\_search

**Query:**
"What are the latest updates in AI this week?"

**What happens:**
Claude identifies this as a real-time information request and calls `tavily_search`.

* Tavily fetches recent news, blogs, and updates
* Claude selects the most relevant sources
* Results are synthesized into a concise summary

**Outcome:**
A current, source-backed overview of the latest AI developments.

***

### tavily\_extract

**Query:**
"Summarize this article: [https://example.com/ai-report](https://example.com/ai-report)"

**What happens:**
Claude detects a URL and calls `tavily_extract`.

* Tavily extracts clean content from the page
* Removes boilerplate (ads, navigation, etc.)
* Returns structured text

Claude then summarizes or analyzes the extracted content.

**Outcome:**
A clean, accurate summary of the article without noise.

***

### tavily\_crawl

**Query:**
"Go through Stripe's documentation and explain how subscriptions work"

**What happens:**
Claude needs multiple pages to answer this.

* Calls `tavily_crawl` on the documentation root
* Tavily traverses linked pages
* Relevant pages are collected and processed

Claude aggregates information across pages and generates a unified explanation.

**Outcome:**
A complete answer built from multiple documentation pages.

***

### tavily\_research

**Query:**
"Do a deep analysis of the AI chip market and key players"

**What happens:**
Claude recognizes this as a complex, multi-step research task.

* Calls `tavily_research` (deep research agent)
* Tavily performs multi-source search, extraction, and synthesis
* Iteratively refines findings across sources

Claude then compiles a structured, high-quality research report.

**Outcome:**
A comprehensive, multi-source analysis rather than a simple summary.

***

# Plugin

The Tavily Plugin brings Tavily's tools directly into Claude's developer surfaces — **Claude Code** (terminal) and **Cowork** (desktop). Install it once and use Tavily via slash commands or let Claude invoke the right skill automatically.

## Install

### Prereq: Tavily API key

Add to `~/.claude/settings.json`:

```json theme={null}
{
  "env": {
    "TAVILY_API_KEY": "tvly-your-key-here"
  }
}
```

Get a key at [tavily.com](https://tavily.com).

### Option A — Claude Code (CLI)

```
/plugin install tavily
```

Then `/clear` and `Ctrl+C` to restart.

### Option B — Cowork (desktop)

1. Click the **+** icon
2. **Add Plugins** → **Anthropic and Partners**
3. Search **Tavily** → **Add**
4. (Optional) Customize via settings

### Use (both surfaces)

```
/tavily:search latest news on EU AI Act
/tavily:research electric vehicle market 2026
/tavily:crawl https://docs.tavily.com
/tavily:extract https://example.com/article
```

Or just ask Claude naturally — it'll pick the right skill automatically.

***

## Learn more

* Claude Connectors Directory - [https://claude.com/connectors](https://claude.com/connectors)
* Use Tavily with Anthropic SDK - [https://docs.tavily.com/documentation/integrations/anthropic](https://docs.tavily.com/documentation/integrations/anthropic)


# Composio
Source: https://docs.tavily.com/documentation/integrations/composio

Tavily is now available for integration through Composio.

## Introduction

Integrate Tavily with Composio to enhance your AI workflows with powerful web search capabilities. Composio provides a platform to connect your AI agents to external tools like Tavily, making it easy to incorporate real-time web search and data extraction into your applications.

## Step-by-Step Integration Guide

### Step 1: Install Required Packages

Install the necessary Python packages:

```bash theme={null}
pip install composio composio-openai openai python-dotenv
```

### Step 2: Set Up API Keys

* **OpenAI API Key:** [Get your OpenAI API key here](https://platform.openai.com/account/api-keys)
* **Composio API Key:** [Get your Composio API key here](https://app.composio.dev/dashboard)

Set these as environment variables in your terminal or add them to your environment configuration file:

```bash theme={null}
export OPENAI_API_KEY=your_openai_api_key
export COMPOSIO_API_KEY=your_composio_api_key
```

### Step 3: Connect Tavily to Composio

```python theme={null}
from composio import Composio
from dotenv import load_dotenv

load_dotenv()

composio = Composio()

# Use composio managed auth
auth_config = composio.auth_configs.create(
    toolkit="tavily",
    options={
        "type": "use_custom_auth",
        "auth_scheme": "API_KEY",
        "credentials": {}
    }
)
print(auth_config)
auth_config_id = auth_config.id

user_id = "your-user-id"
connection_request = composio.connected_accounts.link(user_id, auth_config_id)
print(connection_request.redirect_url)
```

### Step 4: Example Use Case

```python theme={null}
from composio import Composio
from composio_openai import OpenAIProvider
from openai import OpenAI
import os
from dotenv import load_dotenv

load_dotenv()
# Initialize OpenAI client with API key
client = OpenAI()

# Initialize Composio toolset
composio = Composio(
    api_key=os.getenv("COMPOSIO_API_KEY"),
    provider=OpenAIProvider()
)

user_id = "your-user-id"

# Get the Tavily tool with all available parameters
tools = composio.tools.get(user_id,
    toolkits=['TAVILY']
)

# Define the market research task with specific parameters
task = {
    "query": "Analyze the competitive landscape of AI-powered customer service solutions in 2024",
    "search_depth": "advanced",  
    "include_answer": True,      
    "max_results": 10,  
    # Focus on relevant industry sources         
    "include_domains": [        
        "techcrunch.com",
        "venturebeat.com",
        "forbes.com",
        "gartner.com",
        "marketsandmarkets.com"
    ],
}

# Send request to LLM
messages = [{"role": "user", "content": str(task)}]

response = client.chat.completions.create(
    model="gpt-4.1",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)

# Handle tool call via Composio
execution_result = None
response_message = response.choices[0].message

if response_message.tool_calls:
    execution_result = composio.provider.handle_tool_calls(user_id,response)
    print("Execution Result:", execution_result)
    messages.append(response_message)
    
    # Add tool response messages
    for tool_call, result in zip(response_message.tool_calls, execution_result):
        messages.append({
            "role": "tool",
            "content": str(result["data"]),
            "tool_call_id": tool_call.id
        })
    
    # Get final response from LLM
    final_response = client.chat.completions.create(
        model="gpt-4.1",
        messages=messages
    )
    print("\nMarket Research Summary:")
    print(final_response.choices[0].message.content)
else:
    print("LLM responded directly (no tool used):", response_message.content)
```

## Additional Use Cases

1. **Research Automation**: Automate the collection and summarization of research data
2. **Content Curation**: Gather and organize information from multiple sources
3. **Real-time Data Integration**: Keeping your AI models up-to-date with the latest information.


# CrewAI
Source: https://docs.tavily.com/documentation/integrations/crewai

Integrate Tavily with CrewAI to build powerful AI agents that can search the web.

## Introduction

This guide shows you how to integrate Tavily with CrewAI to create sophisticated AI agents that can search the web and extract content. By combining CrewAI's multi-agent framework with Tavily's real-time web search capabilities, you can build AI systems that research, analyze, and process web information autonomously.

## Prerequisites

Before you begin, make sure you have:

* An OpenAI API key from [OpenAI Platform](https://platform.openai.com/)
* A Tavily API key from [Tavily Dashboard](https://app.tavily.com/sign-in)

## Installation

Install the required packages:

> **Note:** The stable python versions to use with CrewAI are `Python >=3.10 and Python <3.13` .

```bash theme={null}
pip install 'crewai[tools]'
pip install pydantic
```

## Setup

Set up your API keys:

```python theme={null}
import os

# Set your API keys
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
os.environ["TAVILY_API_KEY"] = "your-tavily-api-key"
```

## Using Tavily Search with CrewAI

CrewAI provides built-in Tavily tools that make it easy to integrate web search capabilities into your AI agents. The `TavilySearchTool` allows your agents to search the web for real-time information.

```python theme={null}
import os
from crewai import Agent, Task, Crew
from crewai_tools import TavilySearchTool
```

```python theme={null}
# Initialize the Tavily search tool
tavily_tool = TavilySearchTool()
```

```python theme={null}
# Create an agent that uses the tool
researcher = Agent(
    role='News Researcher',
    goal='Find trending information about AI agents',
    backstory='An expert News researcher specializing in technology, focused on AI.',
    tools=[tavily_tool],
    verbose=True
)
```

```python theme={null}
# Create a task for the agent
research_task = Task(
    description='Search for the top 3 Agentic AI trends in 2025.',
    expected_output='A JSON report summarizing the top 3 AI trends found.',
    agent=researcher
)
```

```python theme={null}
# Form the crew and execute the task
crew = Crew(
    agents=[researcher],
    tasks=[research_task],
    verbose=True
)

result = crew.kickoff()
print(result)
```

### Customizing search tool parameters

**Example:**

```python theme={null}
from crewai_tools import TavilySearchTool

# You can configure the tool with specific parameters
tavily_search_tool = TavilySearchTool(
    search_depth="advanced",
    max_results=10,
    include_answer=True
)
```

You can customize the search tool by passing parameters to configure its behavior.Below are available parameters in crewai integration:

**Available Parameters:**

* `query` (str): Required. The search query string.
* `search_depth` (Literal\["basic", "advanced"], optional): The depth of the search. Defaults to "basic".
* `topic` (Literal\["general", "news", "finance"], optional): The topic to focus the search on. Defaults to "general".
* `time_range` (Literal\["day", "week", "month", "year"], optional): The time range for the search. Defaults to None.
* `max_results` (int, optional): The maximum number of search results to return. Defaults to 5.
* `include_domains` (Sequence\[str], optional): A list of domains to prioritize in the search. Defaults to None.
* `exclude_domains` (Sequence\[str], optional): A list of domains to exclude from the search. Defaults to None.
* `include_answer` (Union\[bool, Literal\["basic", "advanced"]], optional): Whether to include a direct answer synthesized from the search results. Defaults to False.
* `include_raw_content` (bool, optional): Whether to include the raw HTML content of the searched pages. Defaults to False.
* `include_images` (bool, optional): Whether to include image results. Defaults to False.
* `timeout` (int, optional): The request timeout in seconds. Defaults to 60.

> **Explore More Parameters**: For a complete list of available parameters and their descriptions, visit our [API documentation](/documentation/api-reference/endpoint/search) to discover all the customization options available for search operations.

<Accordion title="Full Code Example - Search">
  ```python theme={null}
  import os
  from crewai import Agent, Task, Crew
  from crewai_tools import TavilySearchTool

  # Set up environment variables
  os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
  os.environ["TAVILY_API_KEY"] = "your-tavily-api-key"

  # Initialize the tool
  tavily_tool = TavilySearchTool()

  # Create an agent that uses the tool
  researcher = Agent(
      role='News Researcher',
      goal='Find trending information about AI agents',
      backstory='An expert News researcher specializing in technology, focused on AI.',
      tools=[tavily_tool],
      verbose=True
  )

  # Create a task for the agent
  research_task = Task(
      description='Search for the top 3 Agentic AI trends in 2025.',
      expected_output='A JSON report summarizing the top 3 AI trends found.',
      agent=researcher
  )

  # Form the crew and kick it off
  crew = Crew(
      agents=[researcher],
      tasks=[research_task],
      verbose=True
  )

  result = crew.kickoff()
  print(result)

  ```
</Accordion>

## Using Tavily Extract with CrewAI

The `TavilyExtractorTool` allows your CrewAI agents to extract and process content from specific web pages. This is particularly useful for content analysis, data collection, and research tasks.

```python theme={null}
import os
from crewai import Agent, Task, Crew
from crewai_tools import TavilyExtractorTool
```

```python theme={null}
# Initialize the Tavily extractor tool
tavily_tool = TavilyExtractorTool()
```

```python theme={null}
# Create an agent that uses the tool
extractor_agent = Agent(
    role='Web Page Content Extractor',
    goal='Extract key information from the given web pages',
    backstory='You are an expert at extracting relevant content from websites using the Tavily Extract.',
    tools=[tavily_tool],
    verbose=True
)
```

```python theme={null}
# Define a task for the agent
extract_task = Task(
    description='Extract the main content from the URL https://en.wikipedia.org/wiki/Lionel_Messi .',
    expected_output='A JSON string containing the extracted content from the URL.',
    agent=extractor_agent
)
```

```python theme={null}
# Create and run the crew
crew = Crew(
    agents=[extractor_agent],
    tasks=[extract_task],
    verbose=False
)

result = crew.kickoff()
print(result)
```

### Customizing extract tool parameters

**Example:**

```python theme={null}
from crewai_tools import TavilyExtractorTool

# You can configure the tool with specific parameters
tavily_extract_tool = TavilyExtractorTool(
    extract_depth="advanced",
    include_images=True,
    timeout=45
)
```

You can customize the extract tool by passing parameters to configure its behavior. Below are available parameters in crewai integration:

**Available Parameters:**

* `urls` (Union\[List\[str], str]): Required. A single URL string or a list of URL strings to extract data from.
* `include_images` (Optional\[bool]): Whether to include images in the extraction results. Defaults to False.
* `extract_depth` (Literal\["basic", "advanced"]): The depth of extraction. Use "basic" for faster, surface-level extraction or "advanced" for more comprehensive extraction. Defaults to "basic".
* `timeout` (int): The maximum time in seconds to wait for the extraction request to complete. Defaults to 60.

> **Explore More Parameters**: For a complete list of available parameters and their descriptions, visit our [API documentation](/documentation/api-reference/endpoint/extract) to discover all the customization options available for extract operations.

<Accordion title="Full Code Example - Extract">
  ```python theme={null}
  import os
  from crewai import Agent, Task, Crew
  from crewai_tools import TavilyExtractorTool

  # Set up environment variables
  os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
  os.environ["TAVILY_API_KEY"] = "your-tavily-api-key"

  # Initialize the Tavily extractor tool
  tavily_tool = TavilyExtractorTool()

  # Create an agent that uses the tool
  extractor_agent = Agent(
      role='Web Page Content Extractor',
      goal='Extract key information from the given web pages',
      backstory='You are an expert at extracting relevant content from websites using the Tavily Extract.',
      tools=[tavily_tool],
      verbose=True
  )

  # Define a task for the agent
  extract_task = Task(
      description='Extract the main content from the URL https://en.wikipedia.org/wiki/Lionel_Messi .',
      expected_output='A JSON string containing the extracted content from the URL.',
      agent=extractor_agent
  )

  # Create and execute the crew
  crew = Crew(
      agents=[extractor_agent],
      tasks=[extract_task],
      verbose=True
  )

  # Run the extraction
  result = crew.kickoff()
  print("Extraction Results:")
  print(result)
  ```
</Accordion>

## Using Tavily Research with CrewAI

The `TavilyResearchTool` lets your CrewAI agents kick off Tavily research tasks, returning a synthesized, cited report (or a stream of progress events) instead of raw search results. Use it when an agent needs an investigative answer rather than a single web search.

> **Note:** Using the `TavilyResearchTool` requires the `tavily-python` library in addition to `crewai-tools`. Install it alongside CrewAI tools:
>
> ```bash theme={null}
> uv add 'crewai[tools]' tavily-python
> ```

```python theme={null}
import os
from crewai import Agent, Task, Crew
from crewai_tools import TavilyResearchTool
```

```python theme={null}
# Initialize the Tavily research tool
tavily_tool = TavilyResearchTool()
```

```python theme={null}
# Create an agent that uses the tool
researcher = Agent(
    role="Research Analyst",
    goal="Investigate questions and produce concise, well-cited briefings.",
    backstory=(
        "You are a meticulous analyst who delegates web research to the Tavily "
        "Research tool, then synthesizes the findings into short briefings."
    ),
    tools=[tavily_tool],
    verbose=True,
)
```

```python theme={null}
# Create a task for the agent
research_task = Task(
    description=(
        "Investigate notable open-source agent orchestration frameworks released "
        "in the last six months and summarize their differentiators."
    ),
    expected_output="A bulleted briefing with citations.",
    agent=researcher,
)
```

```python theme={null}
# Form the crew and execute the task
crew = Crew(agents=[researcher], tasks=[research_task])
print(crew.kickoff())
```

### Customizing research tool parameters

**Example:**

```python theme={null}
from crewai_tools import TavilyResearchTool

# You can configure the tool with specific defaults for every call
tavily_research_tool = TavilyResearchTool(
    model="pro",                # use Tavily's most capable research model
    citation_format="apa",      # APA-style citations
)
```

You can customize the research tool by passing parameters to configure its behavior. Defaults set on the tool instance apply to every call, and any parameter can also be overridden per-call via the agent's tool input. Below are available parameters in the crewai integration:

**Available Parameters:**

* `input` (str): Required. The research task or question to investigate.
* `model` (Literal\["mini", "pro", "auto"], optional): The Tavily research model. `"auto"` lets Tavily pick; `"mini"` is faster and cheaper; `"pro"` is the most capable. Defaults to `"auto"`.
* `output_schema` (dict, optional): Optional JSON Schema that structures the research output. Useful when you want strictly typed results. Defaults to None.
* `stream` (bool, optional): When `True`, the tool returns an iterator of SSE chunks emitting research progress and the final result instead of a single string. Defaults to False.
* `citation_format` (Literal\["numbered", "mla", "apa", "chicago"], optional): Citation format for the report. Defaults to `"numbered"`.

#### Stream research progress

When `stream=True`, the tool returns a generator (or async generator from `_arun`) of SSE chunks so your application can surface incremental progress:

```python theme={null}
tavily_tool = TavilyResearchTool(stream=True)

for chunk in tavily_tool.run(input="Summarize recent advances in retrieval-augmented generation."):
    print(chunk)
```

#### Structured output via JSON Schema

Pass an `output_schema` when you need a typed result instead of a free-form report:

```python theme={null}
output_schema = {
    "type": "object",
    "properties": {
        "summary": {"type": "string"},
        "key_points": {"type": "array", "items": {"type": "string"}},
        "sources": {"type": "array", "items": {"type": "string"}},
    },
    "required": ["summary", "key_points", "sources"],
}

tavily_tool = TavilyResearchTool(output_schema=output_schema)
```

> **Explore More Parameters**: For a complete list of available parameters and their descriptions, visit our [API documentation](/documentation/api-reference/endpoint/research) to discover all the customization options available for research operations.

<Accordion title="Full Code Example - Research">
  ```python theme={null}
  import os
  from crewai import Agent, Task, Crew
  from crewai_tools import TavilyResearchTool

  # Set up environment variables
  os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
  os.environ["TAVILY_API_KEY"] = "your-tavily-api-key"

  # Initialize the Tavily research tool
  tavily_tool = TavilyResearchTool()

  # Create an agent that uses the tool
  researcher = Agent(
      role="Research Analyst",
      goal="Investigate questions and produce concise, well-cited briefings.",
      backstory=(
          "You are a meticulous analyst who delegates web research to the Tavily "
          "Research tool, then synthesizes the findings into short briefings."
      ),
      tools=[tavily_tool],
      verbose=True,
  )

  # Create a task for the agent
  research_task = Task(
      description=(
          "Investigate notable open-source agent orchestration frameworks released "
          "in the last six months and summarize their differentiators."
      ),
      expected_output="A bulleted briefing with citations.",
      agent=researcher,
  )

  # Form the crew and execute the task
  crew = Crew(
      agents=[researcher],
      tasks=[research_task],
      verbose=True,
  )

  result = crew.kickoff()
  print("Research Results:")
  print(result)
  ```
</Accordion>

For more information about Tavily's capabilities, check out our [API documentation](/documentation/api-reference/introduction) and [best practices](/documentation/best-practices/best-practices-search).


# Devin
Source: https://docs.tavily.com/documentation/integrations/devin

Connect Tavily to Devin through the MCP Marketplace so Devin can search the web, read docs, and ground coding tasks with live web context.

## Introduction

[Devin](https://app.devin.ai/) is an AI software engineering agent that can take a development task, work through multiple steps, use tools, and help build or update applications inside its workspace.

## Why use Tavily with Devin?

Tavily helps Devin go beyond its built-in knowledge when a task depends on the current web.

* **Research before coding** — Compare libraries, frameworks, and services before implementation.
* **Read docs faster** — Pull clean content from relevant pages instead of relying on noisy web pages.
* **Ground implementation choices** — Use live sources when picking packages, SDKs, or workflows.
* **Handle multi-step engineering tasks** — Search, extract, and research can all happen in the same coding flow.

### Example use case

Ask Devin to add email support to a product using the best current provider for your stack. With Tavily enabled, Devin can search for recent comparisons of Resend, Postmark, and SendGrid, read the latest integration docs, choose an option that fits your app, implement the flow, and document the setup in your README.

## Full walkthrough

<Frame>
  <img alt="Installing and using Tavily in Devin through the MCP Marketplace" />
</Frame>

## Setup

Follow this flow in Devin:

<AccordionGroup>
  <Accordion title="Step 1: Open Devin">
    Go to [app.devin.ai](https://app.devin.ai/).
  </Accordion>

  <Accordion title="Step 2: Open settings">
    Click your **username** and open the **Settings** dropdown from the left panel.
  </Accordion>

  <Accordion title="Step 3: Open Connectors">
    In Settings, click **Connectors**.
  </Accordion>

  <Accordion title="Step 4: Open the MCP Marketplace">
    Inside Connectors, open **MCP Marketplace**.
  </Accordion>

  <Accordion title="Step 5: Search for Tavily and enable it">
    Search for **Tavily**, then click **Add**, **Install**, and **Enable**.
  </Accordion>

  <Accordion title="Step 6: Optionally test the tools">
    Click **Test tools** if you want to verify the integration before using it in a task.
  </Accordion>
</AccordionGroup>

<Tip>
  After installation, Devin can use Tavily's web research capabilities during coding tasks whenever live external context is helpful.
</Tip>

## Usage

Once Tavily is enabled:

1. Go back to the main Devin app.
2. Start a new task.
3. Ask Devin to use Tavily MCP as part of the workflow.

Example prompt:

```text theme={null}
Create a Next.js app called `qr-maker`. Use Tavily MCP to pick a QR-code package, build a text-to-QR page, add a README, and commit it.
```

From there, Devin can use Tavily to research package options, inspect relevant documentation, choose a suitable library, and then build the app with the requested deliverables.

## Good tasks for Devin + Tavily

* choosing between actively maintained packages
* implementing against the latest API or SDK docs
* reading framework migration guides
* comparing current tooling options before coding
* gathering source material before writing code or documentation

## Learn more

* [Tavily MCP Documentation](/documentation/mcp)
* [Tavily API Reference](/documentation/api-reference/introduction)


# Dify
Source: https://docs.tavily.com/documentation/integrations/dify

Tavily is now available for no-code integration through Dify.

## Introduction

Integrate Tavily with Dify to enhance your AI workflows without writing any code. Dify is a no-code platform that allows you to build and deploy AI applications using various tools, including the **Tavily Search API** and **Tavily Extract API**. This integration enables access to real-time web data, improving the capabilities of your AI applications.

## How to set up Tavily with Dify

Follow these steps to integrate Tavily with Dify:

<AccordionGroup>
  <Accordion title="Step 1: Log in to Dify">
    Go to [Dify](https://dify.ai/) and log in to your account.
  </Accordion>

  <Accordion title="Step 2: Obtain Your Tavily API Key">
    Go to the [Tavily Dashboard](https://app.tavily.com/home) to obtain your **API key**.
  </Accordion>

  <Accordion title="Step 3: Install the Tavily Tool">
    Install the **Tavily tool** from the [Plugin Marketplace](https://marketplace.dify.ai/plugins/langgenius/tavily) to enable integration with your Dify workflows.
  </Accordion>

  <Accordion title="Step 4: Authorize Tavily in Dify">
    In **Dify**, navigate to **Tools > Tavily > To Authorize** and enter your **Tavily API key** to connect your Dify instance to Tavily.
  </Accordion>
</AccordionGroup>

## Using the Tavily tool in Dify

Tavily can be utilized in various Dify application types:

### Chatflow / Workflow Applications

Dify’s Chatflow and Workflow applications support Tavily tool nodes, which include:

* **Tavily Search API** – Perform dynamic web searches and retrieve up-to-date information.
* **Tavily Extract API** – Extract raw content from web pages.

These nodes allow you to automate tasks such as research, content curation, and real-time data integration into your workflows.

### Agent Applications

In Agent applications, you can integrate the Tavily tool to access web data in real time. Use this to:

* Retrieve structured and relevant search results.
* Extract raw content for further processing.
* Provide accurate, context-aware answers to user queries.

<img alt="defy" />

## Example use case: automated deep research

Use **Tavily Search API** within **Dify** to conduct automated, multi-step searches, iterating through multiple queries to gather, refine, and summarize insights for comprehensive reports.

For a detailed walkthrough, check out this blog post:
[DeepResearch: Building a Research Automation App with Dify](https://dify.ai/blog/deepresearch-building-a-research-automation-app-with-dify)

## Best practices for using Tavily in Dify

* **Design Concise Queries** – Use focused queries to maximize the relevance of search results.
* **Utilize Domain Filtering** – Use the `include_domains` parameter to narrow search results to specific domains.
* **Enable an Agentic Workflow** – Leverage an LLM to dynamically generate and refine queries for Tavily.

***


# ElevenLabs
Source: https://docs.tavily.com/documentation/integrations/elevenlabs

Connect Tavily to ElevenLabs ElevenAgents so your agents can use live web search.

## Introduction

Integrate [Tavily](https://tavily.com/) with [ElevenLabs](https://elevenlabs.io/) through **ElevenAgents** to give your agents access to real-time web search. In ElevenLabs, Tavily is available under **ElevenAgents → Integrations**.

> The Tavily integration in ElevenLabs currently exposes the **`search`** tool only.

## Full setup walkthrough

<Frame>
  <img alt="ElevenLabs Tavily integration walkthrough" />
</Frame>

## Setup instructions

1. Open **ElevenAgents** in ElevenLabs.
2. Click **Integrations**.
3. Click **Add Integration**.
4. In the **Configure** tab:
   * Enter an **API key name**.
   * Enter your [Tavily API key](https://app.tavily.com/home).
   * Click **Connect**.

<Frame>
  <img alt="ElevenLabs integration configuration" />
</Frame>

Once connected, Tavily will be available for use inside your ElevenAgents workflows.

## Testing flow

1. Go to **Agents**.
2. Click **New Agent**.
3. Choose a template or start with a **Blank Agent**.
4. Decide your agent's use case.
5. Add details such as **Name** and **Goal**.
6. Click **Create Agent**.
7. Configure the agent settings, such as:
   * **Voice**
   * **First Message**
   * **LLM**
   * any other relevant options

<Frame>
  <img alt="ElevenLabs agent configuration" />
</Frame>

8. Open the **Tools** section.
9. Add **Tavily search**.
10. **Publish** the agent or use **Preview**.
11. Test the agent end to end.

<Frame>
  <img alt="ElevenLabs Tools section with Tavily search" />
</Frame>

## Why use Tavily with ElevenLabs?

* Give voice and conversational agents access to up-to-date information.
* Add live web search without building a custom retrieval layer.
* Quickly prototype research, support, and assistant workflows inside ElevenAgents.


# FlowiseAI
Source: https://docs.tavily.com/documentation/integrations/flowise

Tavily is now available for integration through Flowise.

## Introduction

Integrate [Tavily with FlowiseAI](https://docs.flowiseai.com/integrations/langchain/tools/tavily-ai) to enhance your AI workflows with powerful web search capabilities. Flowise provides a no-code platform for building AI applications, and the Tavily integration offers real-time, accurate search results tailored for LLMs and RAG (Retrieval-Augmented Generation) systems.

Set up Tavily in Flowise to create chatflows or agent flows that can automate research, track news, or feed relevant data into your connected applications.

## How to set up Tavily with Flowise

Follow these steps to integrate Tavily with Flowise:

<AccordionGroup>
  <Accordion title="Step 1: Log in to Flowise">
    [Login](https://flowiseai.com/) to your Flowise account.
  </Accordion>

  <Accordion title="Step 2: Create a New Flow">
    Create a new flow in Flowise:

    1. Click "Create New Flow"
    2. Select either "Chat Flow" or "Agent Flow" as the type
    3. Name your flow (e.g., "Research Assistant")
  </Accordion>

  <Accordion title="Step 3: Add Tavily Node">
    Add the Tavily node to your flow:

    **For Chat Flow:**

    1. Click on the (+) button
    2. Navigate to **LangChain > Tools > Tavily API**
    3. Drag the Tavily node into your flow

    **For Agent Flow:**

    1. Click on the (+) button
    2. Navigate to **Tools > Tavily API**
    3. Drag the Tavily node into your flow
  </Accordion>

  <Accordion title="Step 4: Configure Tavily Node">
    Configure the Tavily node with your credentials and parameters:

    1. Enter your Tavily API key in the credentials section
    2. Configure additional parameters, for example:
       * **Search Depth:** Choose between 'basic' or 'advanced'
       * **Max Results:** Set the number of results to return
       * **Include Domains:** Specify domains to include in search
       * **Exclude Domains:** Specify domains to exclude from search
  </Accordion>

  <Accordion title="Step 5: Connect Nodes">
    Connect the Tavily node to other nodes in your flow:

    1. Connect to any node that accepts tool inputs
    2. Connect to an LLM node for query processing
    3. Connect to a Response node to format results
  </Accordion>
</AccordionGroup>

## Using Tavily in Flowise

Tavily can be utilized in various Flowise application types:

### Chatflow Applications

Flowise's Chatflow applications support Tavily tool node. This node allows you to automate tasks such as research, content curation, and real-time data integration into your workflows.

### Agent Applications

In Agent applications, you can integrate the Tavily tool to access web data in real time. Use this to:

* Retrieve structured and relevant search results
* Extract raw content for further processing
* Provide accurate, context-aware answers to user queries

<img alt="Flowise Tavily Integration" />


# Google ADK
Source: https://docs.tavily.com/documentation/integrations/google-adk

Connect your Google ADK agent to Tavily's AI-focused search, extraction, and crawling platform for real-time web intelligence.

## Introduction

The Tavily MCP Server connects your ADK agent to Tavily's AI-focused search, extraction, and crawling platform. This gives your agent the ability to perform real-time web searches, intelligently extract specific data from web pages, and crawl or create structured maps of websites.

## Prerequisites

Before you begin, make sure you have:

* Python 3.9 or later
* pip for installing packages
* A [Tavily API key](https://app.tavily.com/home) (sign up for free if you don't have one)
* A [Gemini API key](https://aistudio.google.com/app/apikey) for Google AI Studio

## Installation

Install ADK by running:

```bash theme={null}
pip install google-adk mcp
```

## Building Your Agent

### Step 1: Create an Agent Project

Run the `adk create` command to start a new agent project:

```bash theme={null}
adk create my_agent
```

This creates a new directory with the following structure:

```
my_agent/
    agent.py      # main agent code
    .env          # API keys or project IDs
    __init__.py
```

### Step 2: Update Your Agent Code

Edit the `my_agent/agent.py` file to integrate Tavily. Choose either **Remote MCP Server** or **Local MCP Server**:

<CodeGroup>
  ```python Remote MCP Server theme={null}
  from google.adk.agents import Agent
  from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPServerParams
  from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset
  import os

  # Get API key from environment
  TAVILY_API_KEY = os.getenv("TAVILY_API_KEY")

  root_agent = Agent(
      model="gemini-2.5-pro",
      name="tavily_agent",
      instruction="You are a helpful assistant that uses Tavily to search the web, extract content, and explore websites. Use Tavily's tools to provide up-to-date information to users.",
      tools=[
          MCPToolset(
              connection_params=StreamableHTTPServerParams(
                  url="https://mcp.tavily.com/mcp/",
                  headers={
                      "Authorization": f"Bearer {TAVILY_API_KEY}",
                  },
              ),
          )
      ],
  )
  ```

  ```python Local MCP Server theme={null}
  from google.adk.agents import Agent
  from google.adk.tools.mcp_tool.mcp_session_manager import StdioConnectionParams
  from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset
  from mcp import StdioServerParameters
  import os

  # Get API key from environment
  TAVILY_API_KEY = os.getenv("TAVILY_API_KEY")

  root_agent = Agent(
      model="gemini-2.5-pro",
      name="tavily_agent",
      instruction="You are a helpful assistant that uses Tavily to search the web, extract content, and explore websites.",
      tools=[
          MCPToolset(
              connection_params=StdioConnectionParams(
                  server_params=StdioServerParameters(
                      command="npx",
                      args=[
                          "-y",
                          "tavily-mcp@latest",
                      ],
                      env={
                          "TAVILY_API_KEY": TAVILY_API_KEY,
                      }
                  ),
                  timeout=30,
              ),
          )
      ],
  )
  ```
</CodeGroup>

### Step 3: Set Your API Keys

Update the `my_agent/.env` file with your API keys:

```bash theme={null}
echo 'GOOGLE_API_KEY="YOUR_GEMINI_API_KEY"' >> my_agent/.env
echo 'TAVILY_API_KEY="YOUR_TAVILY_API_KEY"' >> my_agent/.env
```

Or manually edit the `.env` file:

```
GOOGLE_API_KEY="your_gemini_api_key_here"
TAVILY_API_KEY="your_tavily_api_key_here"
```

### Step 4: Run Your Agent

You can run your ADK agent in two ways:

#### Run with Command-Line Interface

Run your agent using the `adk run` command:

```bash theme={null}
adk run my_agent
```

This starts an interactive command-line interface where you can chat with your agent and test Tavily's capabilities.

#### Run with Web Interface

Start the ADK web interface for a visual testing experience:

```bash theme={null}
adk web --port 8000
```

**Note:** Run this command from the parent directory that contains your `my_agent/` folder. For example, if your agent is inside `agents/my_agent/`, run `adk web` from the `agents/` directory.

This starts a web server with a chat interface. Access it at `http://localhost:8000`, select your agent from the dropdown, and start chatting.

## Example Usage

Once your agent is set up and running, you can interact with it through the command-line interface or web interface. Here's a simple example:

**User Query:**

```
Find all documentation pages on tavily.com and provide instructions on how to get started with Tavily
```

The agent automatically combines multiple Tavily tools to provide comprehensive answers, making it easy to explore websites and gather information without manual navigation.

<img alt="Tavily-ADK" />

## Available Tools

Once connected, your agent gains access to Tavily's powerful web intelligence tools:

### tavily-search

Execute a search query to find relevant information across the web.

### tavily-extract

Extract structured data from any web page. Extract text, links, and images from single pages or batch process multiple URLs efficiently.

### tavily-map

Traverses websites like a graph and can explore hundreds of paths in parallel with intelligent discovery to generate comprehensive site maps.

### tavily-crawl

Traversal tool that can explore hundreds of paths in parallel with built-in extraction and intelligent discovery.


# Gradium
Source: https://docs.tavily.com/documentation/integrations/gradium

Use Tavily web search with Gradium voice AI agents.

## Introduction

[Gradium](https://gradium.ai/) is a voice AI platform for building live speech agents. Pairing Gradium with [Tavily](https://tavily.com/) gives your agent access to real-time web search, extraction, research, and crawling.

In a Gradium voice agent, Tavily acts as the web context layer: the user speaks a request, the agent turns it into a structured search, Tavily returns current web results, and Gradium speaks the answer back.

<CardGroup>
  <Card title="Tavily" icon="arrow-up-right-from-square" href="https://www.tavily.com/">
    Explore Tavily's web search and research APIs.
  </Card>

  <Card title="Paris rental voice agent" icon="github" href="https://github.com/gradium-ai/gradbot/tree/main/demos/paris_rental_agent">
    See a Gradbot demo that uses voice AI to search for Paris rentals.
  </Card>
</CardGroup>

## Voice-controlled web search

A voice search agent usually follows this loop:

1. The user asks a spoken question, such as "Find two-bedroom rentals near Canal Saint-Martin under 2,500 euros."
2. Gradium Speech-to-Text transcribes the request in real time.
3. Your agent decides whether it needs fresh web context and calls Tavily with a focused query.
4. Tavily returns search results and source content for the agent to inspect.
5. The agent filters, compares, and summarizes the results.
6. Gradium Text-to-Speech streams the answer back to the user.

This pattern lets users control web search without typing. They can refine the search conversationally, ask for tradeoffs, compare sources, or narrow results by criteria like budget, neighborhood, date, availability, or ranking.

## Core wiring

The Gradbot demo exposes search as a voice-agent tool. Gradium handles the live STT and TTS session, while the agent decides when to call `run_apartment_search`.

### Agent session config

```python theme={null}
def on_start(msg: dict) -> gradbot.SessionConfig:
    return gradbot.SessionConfig(
        voice_id="ubuXFxVQwVYnZQhy",
        instructions=SYSTEM_PROMPT,
        language=gradbot.LANGUAGES["en"],
        tools=build_tools(),
        silence_timeout_s=0.0,
        **config.session_kwargs,
    )

await gradbot.websocket.handle_session(
    websocket,
    config=config,
    on_start=on_start,
    on_tool_call=on_tool_call,
)
```

### Search tool definition

```python theme={null}
gradbot.ToolDef(
    name="run_apartment_search",
    description=(
        "Run a fresh apartment search and return top matches. "
        "Call only when the user explicitly asks to search."
    ),
    parameters_json=json.dumps({
        "type": "object",
        "properties": {
            "max_results": {"type": "integer"},
            "allow_unconfirmed_profile": {"type": "boolean"},
        },
        "required": [],
    }),
)
```

When the model calls the tool, the voice handler routes it into the same search logic used by the REST API and sends a compact result back to the agent before it speaks.

```python theme={null}
async def on_tool_call(handle, input_handle, websocket):
    if handle.name == "run_apartment_search":
        result = await assistant_tools.run_apartment_search(
            db,
            user_id,
            max_results=int((handle.args or {}).get("max_results") or 10),
            allow_unconfirmed_profile=bool(
                (handle.args or {}).get("allow_unconfirmed_profile")
            ),
        )
        await handle.send_json(_voice_summarize_search(result))
```

The shared search logic eventually calls Tavily with the focused query built from the user's confirmed profile.

```python theme={null}
response = await httpx.AsyncClient().post(
    "https://api.tavily.com/search",
    json={
        "api_key": tavily_api_key,
        "query": "location appartement Paris 2 chambres 2500 euros",
        "search_depth": "basic",
        "max_results": 5,
        "include_raw_content": True,
    },
    timeout=20.0,
)

results = response.json()["results"]
```

## When to use Tavily with Gradium

* **Live search assistants:** Answer questions that depend on current web results.
* **Research agents:** Collect, compare, and summarize web sources while keeping the conversation hands-free.
* **Shopping, travel, and real estate workflows:** Let users narrow options by speaking constraints naturally.
* **Customer support agents:** Fetch public documentation or status information while the caller stays in a voice conversation.

## Resources

* [Gradium documentation index](https://docs.gradium.ai/llms.txt)
* [Paris rental voice agent demo](https://github.com/gradium-ai/gradbot/tree/main/demos/paris_rental_agent)
* [Tavily Search API reference](https://docs.tavily.com/documentation/api-reference/endpoint/search)

## Demo

The [Paris rental voice agent](https://github.com/gradium-ai/gradbot/tree/main/demos/paris_rental_agent) shows how a Gradbot application can combine a spoken interface with web search. Use it as a reference for the agent loop: listen to the user, call a web search tool, reason over the results, and respond with speech.


# Haystack
Source: https://docs.tavily.com/documentation/integrations/haystack

Use Tavily inside Haystack pipelines with the `tavily-haystack` integration.

## Introduction

[Haystack](https://haystack.deepset.ai/) is an open-source framework for building production-ready LLM applications and RAG pipelines in Python.

Tavily integrates with Haystack through the [`tavily-haystack`](https://pypi.org/project/tavily-haystack/) package maintained by deepset. It exposes a `TavilyWebSearch` component that queries Tavily Search and returns Haystack `Document` objects alongside the source URLs.

You can also review the upstream integration page in the [Haystack integrations directory](https://haystack.deepset.ai/integrations/tavily).

## Installation

Install the integration package:

```bash theme={null}
pip install tavily-haystack
```

## Credentials

Set your Tavily API key as an environment variable:

```bash theme={null}
export TAVILY_API_KEY="tvly-your-api-key"
```

By default, `TavilyWebSearch` reads from `TAVILY_API_KEY`, but you can also pass the key explicitly with `Secret.from_token(...)`.

## Basic Usage

Use `TavilyWebSearch` to fetch web results as Haystack `Document` objects:

```python theme={null}
from haystack_integrations.components.websearch.tavily import TavilyWebSearch

web_search = TavilyWebSearch(top_k=5)

result = web_search.run(query="What is Haystack by deepset?")
documents = result["documents"]
links = result["links"]
```

If you want to configure Tavily directly inside the component, pass an API key and `search_params`:

```python theme={null}
from haystack.utils import Secret
from haystack_integrations.components.websearch.tavily import TavilyWebSearch

web_search = TavilyWebSearch(
    api_key=Secret.from_token("tvly-your-api-key"),
    top_k=5,
    search_params={"search_depth": "advanced"},
)
```

## Using Tavily in a Haystack Pipeline

Here is a simple RAG-style pipeline that searches the web with Tavily, builds a prompt from the returned documents, and sends the prompt to a chat model:

```python theme={null}
from haystack import Pipeline
from haystack.utils import Secret
from haystack.components.builders.chat_prompt_builder import ChatPromptBuilder
from haystack.components.generators.chat import OpenAIChatGenerator
from haystack.dataclasses import ChatMessage
from haystack_integrations.components.websearch.tavily import TavilyWebSearch

web_search = TavilyWebSearch(top_k=3)

prompt_template = [
    ChatMessage.from_system("You are a helpful assistant."),
    ChatMessage.from_user(
        "Given the information below:\n"
        "{% for document in documents %}{{ document.content }}\n{% endfor %}\n"
        "Answer the following question: {{ query }}\n"
        "Answer:"
    ),
]

prompt_builder = ChatPromptBuilder(
    template=prompt_template,
    required_variables={"query", "documents"},
)

llm = OpenAIChatGenerator(
    api_key=Secret.from_env_var("OPENAI_API_KEY"),
    model="gpt-4o-mini",
)

pipe = Pipeline()
pipe.add_component("search", web_search)
pipe.add_component("prompt_builder", prompt_builder)
pipe.add_component("llm", llm)
pipe.connect("search.documents", "prompt_builder.documents")
pipe.connect("prompt_builder.prompt", "llm.messages")

query = "What is Haystack by deepset?"
result = pipe.run(
    data={
        "search": {"query": query},
        "prompt_builder": {"query": query},
    }
)

print(result["llm"]["replies"][0].content)
```

> **Note:** This example uses `OpenAIChatGenerator`, so you will also need to set `OPENAI_API_KEY`.

## Async Usage

`TavilyWebSearch` also supports asynchronous execution with `run_async`:

```python theme={null}
import asyncio
from haystack_integrations.components.websearch.tavily import TavilyWebSearch

async def main():
    web_search = TavilyWebSearch(top_k=3)
    result = await web_search.run_async(query="What is Haystack by deepset?")
    print(f"Found {len(result['documents'])} documents")

asyncio.run(main())
```

## Key Parameters

* `api_key`: Tavily API key. Defaults to the `TAVILY_API_KEY` environment variable.
* `top_k`: Maximum number of search results to return. Defaults to `10`.
* `search_params`: Additional parameters forwarded to Tavily Search, including `search_depth`, `include_answer`, `include_raw_content`, `include_domains`, and `exclude_domains`.

For the full set of supported Tavily search options, see the [Tavily Search API reference](https://docs.tavily.com/documentation/api-reference/endpoint/search).


# LangChain
Source: https://docs.tavily.com/documentation/integrations/langchain

We're excited to partner with Langchain as their recommended search tool!

> **Warning**: The [`langchain_community.tools.tavily_search.tool`](https://python.langchain.com/docs/integrations/tools/tavily_search/) is deprecated. While it remains functional for now, we strongly recommend migrating to the new `langchain-tavily` Python package which supports [Search](#tavily-search), [Extract](#tavily-extract), [Map](#tavily-mapcrawl), [Crawl](#tavily-mapcrawl), [Research](#tavily_research) functionality and receives continuous updates with the latest features.

The [langchain-tavily](https://pypi.org/project/langchain-tavily/) Python package is the official LangChain integration of Tavily, including [Search](#tavily-search), [Extract](#tavily-extract), [Map](#tavily-mapcrawl), [Crawl](#tavily-mapcrawl), [Research](#tavily_research) functionality.

## Installation

```bash theme={null}
pip install -U langchain-tavily
```

### Credentials

We also need to set our Tavily API key. You can get an API key by visiting [this site](https://app.tavily.com/sign-in) and creating an account.

```bash theme={null}
import getpass
import os

if not os.environ.get("TAVILY_API_KEY"):
    os.environ["TAVILY_API_KEY"] = getpass.getpass("Tavily API key:\n")
```

## Tavily Search

Here we show how to instantiate the Tavily search tool. This tool allows you to complete search queries using Tavily's Search API endpoint.

### Available Parameters

The Tavily Search API accepts various parameters to customize the search:

* `max_results` (optional, int): Maximum number of search results to return. Default is 5.
* `topic` (optional, str): Category of the search. Can be "general", "news", or "finance". Default is "general".
* `include_answer` (optional, bool): Include an answer to original query in results. Default is False.
* `include_raw_content` (optional, bool): Include cleaned and parsed HTML of each search result. Default is False.
* `include_images` (optional, bool): Include a list of query related images in the response. Default is False.
* `include_image_descriptions` (optional, bool): Include descriptive text for each image. Default is False.
* `search_depth` (optional, str): Depth of the search, either "basic" or "advanced". Default is "basic".
* `time_range` (optional, str): The time range back from the current date ( publish date ) to filter results - "day", "week", "month", or "year". Default is None.
* `start_date` (optional, str): Will return all results after the specified start date ( publish date ). Required to be written in the format YYYY-MM-DD. Default is None.
* `end_date` (optional, str): Will return all results before the specified end date. Required to be written in the format YYYY-MM-DD. Default is None.
* `include_domains` (optional, List\[str]): List of domains to specifically include. Maximum 300 domains. Default is None.
* `exclude_domains` (optional, List\[str]): List of domains to specifically exclude. Maximum 150 domains. Default is None.
* `include_usage` (optional, bool): Whether to include credit usage information in the response. Default is False.

For a comprehensive overview of the available parameters, refer to the [Tavily Search API documentation](https://docs.tavily.com/documentation/api-reference/endpoint/search)

### Instantiation

```python theme={null}
from langchain_tavily import TavilySearch

tool = TavilySearch(
    max_results=5,
    topic="general",
    # include_answer=False,
    # include_raw_content=False,
    # include_images=False,
    # include_image_descriptions=False,
    # search_depth="basic",
    # time_range="day",
    # start_date=None,
    # end_date=None,
    # include_domains=None,
    # exclude_domains=None,
    # include_usage= False
)
```

### Invoke directly with args

The Tavily search tool accepts the following arguments during invocation:

* `query` (required): A natural language search query
* The following arguments can also be set during invocation: `include_images`, `search_depth`, `time_range`, `include_domains`, `exclude_domains`, `start_date`, `end_date`
* For reliability and performance reasons, certain parameters that affect response size cannot be modified during invocation: `include_answer` and `include_raw_content`. These limitations prevent unexpected context window issues and ensure consistent results.

NOTE: The optional arguments are available for agents to dynamically set. If you set an argument during instantiation and then invoke the tool with a different value, the tool will use the value you passed during invocation.

### Direct Tool Invocation

```python theme={null}
# Basic usage
result = tavily_search.invoke({"query": "What happened at the last wimbledon"})
```

Example output:

```python theme={null}
{
 'query': 'What happened at the last wimbledon',
 'follow_up_questions': None,
 'answer': None,
 'images': [],
 'results': [
   {'url': 'https://en.wikipedia.org/wiki/Wimbledon_Championships',
    'title': 'Wimbledon Championships - Wikipedia',
    'content': 'Due to the COVID-19 pandemic, Wimbledon 2020 was cancelled ...',
    'score': 0.62365627198,
    'raw_content': None},
   {'url': 'https://www.cbsnews.com/news/wimbledon-men-final-carlos-alcaraz-novak-djokovic/',
    'title': "Carlos Alcaraz beats Novak Djokovic at Wimbledon men's final to ...",
    'content': 'In attendance on Sunday was Catherine, the Princess of Wales ...',
    'score': 0.5154731446,
    'raw_content': None}
 ],
 'response_time': 2.3
}
```

### Use with Agent

```python theme={null}
# !pip install -qU langchain langchain-openai langchain-tavily
from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
from langchain_tavily import TavilySearch

# Initialize the Tavily Search tool
tavily_search = TavilySearch(max_results=5, topic="general")

# Initialize the agent with the search tool
agent = create_agent(
    model=ChatOpenAI(model="gpt-5"),
    tools=[tavily_search],
    system_prompt="You are a helpful research assistant. Use web search to find accurate, up-to-date information."
)

# Use the agent
response = agent.invoke({
    "messages": [{"role": "user", "content": "What is the most popular sport in the world? Include only Wikipedia sources."}]
})
```

> **Tip**: For more relevant and time-aware results, inject today's date into your system prompt. This helps the agent understand the current context when searching for recent information. For example: `f"You are a helpful research assistant. Today's date is {datetime.today().strftime('%B %d, %Y')}. Use web search to find accurate, up-to-date information."`

## Tavily Extract

Here we show how to instantiate the Tavily extract tool. This tool allows you to extract content from URLs using Tavily's Extract API endpoint.

### Available Parameters

The Tavily Extract API accepts various parameters:

* `extract_depth` (optional, str): The depth of the extraction, either "basic" or "advanced". Default is "basic".
* `include_images` (optional, bool): Whether to include images in the extraction. Default is False.

For a comprehensive overview of the available parameters, refer to the [Tavily Extract API documentation](https://docs.tavily.com/documentation/api-reference/endpoint/extract)

### Instantiation

```python theme={null}
from langchain_tavily import TavilyExtract

tool = TavilyExtract(
    extract_depth="basic",
    # include_images=False
)
```

### Invoke directly with args

The Tavily extract tool accepts the following arguments during invocation:

* `urls` (required): A list of URLs to extract content from.
* Both `extract_depth` and `include_images` can also be set during invocation

NOTE: The optional arguments are available for agents to dynamically set. If you set an argument during instantiation and then invoke the tool with a different value, the tool will use the value you passed during invocation.

### Direct Tool Invocation

```python theme={null}
# Extract content from a URL
result = tavily_extract.invoke({
    "urls": ["https://en.wikipedia.org/wiki/Lionel_Messi"]
})
```

Example output:

```python theme={null}
{
    'results': [{
        'url': 'https://en.wikipedia.org/wiki/Lionel_Messi',
        'raw_content': 'Lionel Messi\nLionel Andrés "Leo" Messi...',
        'images': []
    }],
    'failed_results': [],
    'response_time': 0.79
}
```

## Tavily Map/Crawl

Tavily provides two complementary tools for website exploration: **Map** and **Crawl**. The `map` tool discovers and lists URLs from a website, providing a structural overview without extracting content. The `crawl` tool then extracts the full content from these discovered URLs, making it ideal for data extraction, documentation indexing, and building knowledge bases.

### Tavily Map

The Map tool discovers all internal links starting from a base URL, perfect for understanding site structure or planning content extraction.

#### Available Parameters

* `url` (required, str): The root URL to begin mapping.
* `instructions` (optional, str): Natural language instructions guiding the mapping process.

For a comprehensive overview, refer to the [Tavily Map API documentation](https://docs.tavily.com/documentation/api-reference/endpoint/map)

#### Instantiation

```python theme={null}
from langchain_tavily import TavilyMap

tool = TavilyMap()
```

#### Direct Tool Invocation

```python theme={null}
# Map a website structure
result = tavily_map.invoke({
    "url": "https://docs.example.com",
    "instructions": "Find all documentation and tutorial pages"
})
```

Example output:

```python theme={null}
{
    'base_url': 'https://docs.example.com',
    'results': [
        'https://docs.example.com',
        'https://docs.example.com/api',
        'https://docs.example.com/tutorials',
        'https://docs.example.com/api/endpoints',
        'https://docs.example.com/tutorials/getting-started'
    ],
    'request_id': 'req_abc123',
    'response_time': 2.1
}
```

### Tavily Crawl

The Crawl tool extracts full content from URLs. It works perfectly with mapped URLs or can be used standalone to crawl from a starting point.

#### Available Parameters

* `url` (required, str): The root URL to begin the crawl.
* `instructions` (optional, str): Natural language instructions guiding content extraction.

For a comprehensive overview, refer to the [Tavily Crawl API documentation](https://docs.tavily.com/documentation/api-reference/endpoint/crawl)

#### Instantiation

```python theme={null}
from langchain_tavily import TavilyCrawl

tool = TavilyCrawl()
```

#### Direct Tool Invocation

```python theme={null}
# Crawl and extract content
result = tavily_crawl.invoke({
    "url": "https://docs.example.com",
    "instructions": "Extract API documentation and code examples"
})
```

Example output:

```python theme={null}
{
    'base_url': 'https://docs.example.com',
    'results': [
        {
            'url': 'https://docs.example.com',
            'raw_content': '# Documentation\nWelcome to our API documentation...'
        },
        {
            'url': 'https://docs.example.com/api',
            'raw_content': '# API Reference\nComplete API reference guide...'
        }
    ],
    'response_time': 4.5,
    'request_id': 'req_abc123'
}
```

## Tavily Research

Here we show how to instantiate the Tavily research tool. This tool allows you to create comprehensive research tasks using Tavily's Research API endpoint, with optional structured output.

### Available Parameters

* `input` (required, str): The research task or question to investigate.
* `model` (optional, str): The research model to use, one of `"mini"`, `"pro"`, or `"auto"`. Default is `"auto"`.
* `output_schema` (optional, dict): A JSON Schema object that defines the structure of the research output. Must include a `properties` field and may optionally include a `required` field.
* `stream` (optional, bool): Whether to stream the research results as they are generated. When `True`, returns a streaming response. Default is `False`.
* `citation_format` (optional, str): The format for citations in the research report, one of `"numbered"`, `"mla"`, `"apa"`, or `"chicago"`. Default is `"numbered"`.

### Instantiation

```python theme={null}
from langchain_tavily import TavilyResearch

tavily_research = TavilyResearch(
    # model="auto",
    # citation_format="numbered",
    # stream=False,
)
```

### Invoke directly with args

The Tavily research tool accepts the following arguments during invocation:

* `input` (required): A natural language research task or question.
* The following arguments can also be set during invocation: `model`, `output_schema`, `stream`, and `citation_format`.

NOTE: The optional arguments are available for agents to dynamically set. If you set an argument during instantiation and then invoke the tool with a different value, the tool will use the value you passed during invocation.

### Direct Tool Invocation

```python theme={null}
# Create a research task with a structured output schema
result = tavily_research.invoke({
    "input": "Research the latest developments in AI and summarize key trends.",
    "model": "mini",
    "citation_format": "apa",
})
```

Example non-streaming response:

```python theme={null}
{
    "request_id": "test-request-123",
    "created_at": "2024-01-01T00:00:00Z",
    "status": "pending",
    "input": "Research the latest developments in AI and summarize key trends.",
    "model": "mini"
}
```

If `stream=True` is set (either in the constructor or at invocation time), `invoke` returns a generator (for sync clients) or async generator (for async clients) that yields the research output as it is generated.

## Tavily Get Research

The Tavily Get Research tool retrieves the results of a previously created research task using its `request_id`.

### Available Parameters

* `request_id` (required, str): The unique identifier of the research task to retrieve.

### Instantiation

```python theme={null}
from langchain_tavily import TavilyGetResearch

tavily_get_research = TavilyGetResearch()
```

### Direct Tool Invocation

```python theme={null}
# Retrieve results for a completed research task
result = tavily_get_research.invoke({
    "request_id": "test-request-123"
})
```

Example response:

```python theme={null}
{
    "request_id": "test-request-123",
    "created_at": "2024-01-01T00:00:00Z",
    "completed_at": "2024-01-01T00:05:00Z",
    "status": "completed",
    "content": "This is a comprehensive research report on AI developments...",
    "sources": [
        {
            "title": "AI Research Paper",
            "url": "https://example.com/ai-paper",
        }
    ]
}
```


# Langflow
Source: https://docs.tavily.com/documentation/integrations/langflow

Integrate Tavily with Langflow, an open-source visual framework for building multi-agent and RAG applications.

## Introduction

Integrate [Tavily with Langflow](https://blog.langflow.org/web-search-in-your-ai-agents-a-langflow-tutorial/) to create powerful AI workflows using a visual interface. Langflow is an open-source tool that provides a visual builder for creating AI agents and workflows, making it easy to incorporate Tavily's search and extraction capabilities into your applications.

## Installation

Langflow works with Python 3.10 to 3.13. You can install it using either UV (recommended) or pip:

```bash theme={null}
# Using UV (recommended)
uv pip install langflow

# Using pip
pip install langflow
```

## Setting Up Tavily Components in Langflow

### Step 1: Launch Langflow

After installation, start Langflow:

```bash theme={null}
langflow run
```

This will start the Langflow server locally at `http://localhost:7860`.

### Step 2: Using Tavily Components

Langflow provides two main Tavily components in the **Tools** section of the components library:

1. **Tavily Search API**: Perform web searches and retrieve relevant information
   * Located under Tools > Tavily Search API
   * **Configuration Options**: Select the component and go to "Controls" to access all available settings. Here are some key examples:
     * Max Results: Number of results to return
     * Search Depth: "basic" or "advanced"
     * *Note: Additional parameters are available in the Controls panel*

2. **Tavily Extract API**: Extract content from web pages
   * Located under Tools > Tavily Extract API
   * **Configuration Options**: Select the component and go to "Controls" to access all available settings. Here are some key examples:
     * Extract Depth: "basic" or "advanced"
     * *Note: Additional parameters are available in the Controls panel*

### Step 3: Configure Your Tavily API Key

To use Tavily components, you need to enter your [Tavily API key](https://app.tavily.com/home) under "Tavily API Key"

## Example Workflows

### Basic Search Workflow

1. Add a Tavily Search component to your flow
2. Connect it to a prompt template
3. Configure the search parameters
4. Add an LLM component to process the results
5. Connect to an output component

### Content Extraction Workflow

1. Add a Tavily Extract component
2. Connect it to a URL input
3. Configure extraction parameters
4. Add processing components as needed
5. Connect to your desired output

## Example Use Cases

1. **Research Assistant**
   * Combine Tavily Search with LLMs for comprehensive research
   * Extract and summarize information from multiple sources

2. **Content Aggregation**
   * Use Tavily Extract to gather content from specific websites
   * Process and format the extracted content

3. **Market Intelligence**
   * Create workflows for competitive analysis
   * Monitor industry trends and news

4. **Documentation Search**
   * Build custom documentation search interfaces
   * Extract and format technical documentation

## Additional Resources

* [Langflow GitHub Repository](https://github.com/langflow-ai/langflow)
* [Langflow Documentation](https://docs.langflow.org)


# LibreChat
Source: https://docs.tavily.com/documentation/integrations/librechat

Use Tavily inside LibreChat for web search, content extraction, and as a built-in agent tool.

<Frame>
  <img alt="Tavily on LibreChat" />
</Frame>

## Introduction

[LibreChat](https://www.librechat.ai/) is an open-source chat platform that supports multiple AI providers, agents, and a configurable web search system. Tavily integrates with LibreChat in three ways:

* **Web search provider** for the built-in `Web Search` feature.
* **Scraper / extract provider** for fetching page contents alongside search.
* **Built-in agent tool** (`Tavily Search`) inside the LibreChat Agent Builder.

This lets your LibreChat conversations and custom agents access real-time, agent-optimized web data without any custom integration code.

## Prerequisites

* A running LibreChat instance (self-hosted or cloud-based). See the [LibreChat docs](https://www.librechat.ai/docs) for installation.
* A [Tavily API key](https://app.tavily.com/home).

## Web search in LibreChat

LibreChat's [Web Search feature](https://www.librechat.ai/docs/features/web_search#tavily) uses a pluggable pipeline of **search provider → scraper → reranker**. Tavily can power both the search and scrape stages.

### Configure Tavily as a provider

<Steps>
  <Step title="Add your Tavily API key">
    Set the environment variable in your LibreChat `.env` file:

    ```bash theme={null}
    TAVILY_API_KEY=your_tavily_api_key
    ```

    LibreChat picks this up automatically for both the search and extract roles.
  </Step>

  <Step title="(Optional) Configure via librechat.yaml">
    If you prefer to manage configuration centrally, reference the environment variable in your `librechat.yaml`:

    ```yaml theme={null}
    webSearch:
      tavilyApiKey: "${TAVILY_API_KEY}"
    ```

    Only reference environment variable names in YAML - for best practices, never embed your API key directly.
  </Step>

  <Step title="Enable web search in a conversation">
    Restart LibreChat, then ensure **Web Search** is enabled in the settings. LibreChat will route queries through Tavily Search, fetch the most relevant pages with Tavily Extract, and feed the results back to the model.
  </Step>
</Steps>

### Why use Tavily for both stages

Tavily can serve as the search provider and the scraper provider simultaneously, so you can run the full web search pipeline with a single API key:

| Stage   | Tavily capability                                                                                         |
| ------- | --------------------------------------------------------------------------------------------------------- |
| Search  | Agent-optimized results with configurable search depth, time-based filtering, and domain include/exclude. |
| Extract | Clean page content with configurable extract depth, plus image and favicon extraction.                    |

Pair Tavily with a supported reranker in `librechat.yaml` if you want an additional ranking stage on top of Tavily's results.

## Tavily as a built-in agent tool

LibreChat's [Agent Builder](https://www.librechat.ai/docs/features/agents) ships with `Tavily Search` as a built-in tool, so any custom agent you build can call Tavily directly.

<Steps>
  <Step title="Create or open an agent">
    Select **Agents** from the endpoint menu, then open the **Agent Builder** in the side panel. Set the agent's name, avatar, model, and instructions.
  </Step>

  <Step title="Enable Tavily Search">
    In the agent's tool list, toggle on **Tavily Search**. If `TAVILY_API_KEY` is not set in the environment, LibreChat will prompt for the key in the UI the first time the tool is used.
  </Step>

  <Step title="Save and test">
    Save the agent and start a conversation. The agent will now call Tavily whenever it needs current web information.
  </Step>
</Steps>

## Best practices

* **Use one Tavily key end-to-end** — the same key powers Web Search and the built-in agent tool, which keeps usage and billing in one place.
* **Combine search + extract** — let Tavily search for sources and extract the most relevant pages before sending content to the model, which keeps context windows tight.
* **Pick the right surface** — use Web Search for ad-hoc chat queries and the built-in `Tavily Search` tool for simple agents. You can also connect the [Tavily MCP server](/documentation/mcp) when an agent needs the full research workflow.

## Resources

* [LibreChat Web Search documentation](https://www.librechat.ai/docs/features/web_search)
* [LibreChat Agents documentation](https://www.librechat.ai/docs/features/agents)
* [Tavily MCP documentation](/documentation/mcp)
* [Tavily API dashboard](https://app.tavily.com/home)


# LlamaIndex
Source: https://docs.tavily.com/documentation/integrations/llamaindex

Search the web from LlamaIndex with Tavily.

<Note>
  This tool has a more extensive example use case documented in a Jupyter notebook [here](https://github.com/run-llama/llama_index/blob/main/llama-index-integrations/tools/llama-index-tools-tavily-research/examples/tavily.ipynb).
</Note>

## Install Tavily and LlamaIndex

The following dependencies are required to properly run the integration:

```bash theme={null}
pip install llama-index-tools-tavily-research llama-index llama-hub tavily-python
```

## Usage

You can use access Tavily in LlamaIndex through the `TavilyToolSpec`.

Here is a simple use case that performs a web search with Tavily and generates an answer to the user's search query:

```python theme={null}
from llama_index.tools.tavily_research.base import TavilyToolSpec
from llama_index.agent.openai import OpenAIAgent

tavily_tool = TavilyToolSpec(
    api_key='tvly-YOUR_API_KEY',
)
agent = OpenAIAgent.from_tools(tavily_tool.to_tool_list())

agent.chat('What happened in the latest Burning Man festival?')
```

`search`: Search for relevant dynamic data based on a query. Returns a list of urls and their relevant content.

This loader is designed to be used as a way to load data as a Tool in an Agent. See [here](https://github.com/emptycrown/llama-hub/tree/main) for examples.


# Make
Source: https://docs.tavily.com/documentation/integrations/make

Tavily is now available for no-code integration through Make.

## Introduction

Integrate [Tavily with Make](https://www.make.com/en/integrations/tavily) to enhance your business processes without writing a single line of code. With Tavily's powerful search and content extraction capabilities, you can seamlessly integrate real-time online information into your Make workflows and automations.

<Frame>
  <img alt="Make-Tavily" />
</Frame>

## How to set up Tavily with Make

<AccordionGroup>
  <Accordion title="Step 1: Log in to Make">
    [Log in](https://www.make.com/en/login) to your Make account.
  </Accordion>

  <Accordion title="Step 2: Create a New Scenario">
    Create a new scenario and select a trigger module that will start your workflow.
  </Accordion>

  <Accordion title="Step 3: Add Tavily as an Action Module">
    Add Tavily as an action module in your scenario and choose between **Perform a Search** or **Extract Raw Content**:

    **Connection:** Connect your Tavily account by entering your [Tavily API key](https://app.tavily.com/home).

    **Configuration:** Set up your parameters:

    **For Search:**

    * Enter your search `query` (can be manually entered or populated from another module's output)
    * Select a `topic` (`general` or `news`)
    * Choose whether to include raw content or generate an answer
    * Specify domains to include or exclude
    * Set search depth and other optional parameters

    **For Extract:**

    * Enter the URL(s) to extract content from (can be a single URL or multiple URLs from another module's output)
    * Choose extraction type (`basic` or `advanced`)

    **Test:** Run a test to verify your configuration.
  </Accordion>

  <Accordion title="Step 4: Process and Use Tavily Results">
    Utilize the search results in your workflow:

    * Process data through additional modules
    * Send information to your CRM or database
    * Generate reports or notifications
    * Feed data into AI models for further processing
  </Accordion>
</AccordionGroup>

## Use cases for Tavily in Make

Leverage Tavily's capabilities to create powerful automated workflows:

* **Competitive Intelligence**: Automatically gather and analyze competitor information
* **Market Research**: Track industry trends and market developments
* **Content Curation**: Collect and organize relevant content for your business
* **Lead Enrichment**: Enhance lead data with real-time information
* **News Monitoring**: Stay updated with the latest developments in your field

## Detailed example - automated market research

Create an automated workflow that performs market research and delivers insights to your team.

<Accordion title="Workflow Steps">
  1. **Trigger:** Schedule the scenario to run daily or weekly
  2. **Generate Search Queries:** Use an AI module to create relevant search queries
  3. **Execute Searches:** Use Tavily to perform multiple searches with the generated queries
  4. **Process Results:** Filter and organize the search results
  5. **Generate Report:** Use an AI module to create a comprehensive report
  6. **Deliver Insights:** Send the report via email or to your team's communication platform
</Accordion>

## Best practices

To optimize your Tavily integration in Make:

* Use the Iterator module to process multiple search results efficiently
* Use filters to process only relevant results
* Use the Aggregator module to combine multiple search results


# Mastra
Source: https://docs.tavily.com/documentation/integrations/mastra

Use Tavily as first-class Mastra tools for web search, extract, crawl, and map via the native package.

## Introduction

[Mastra](https://mastra.ai) is a TypeScript framework for building AI agents and workflows.

The [`@mastra/tavily`](https://mastra.ai/reference/tools/tavily) package exposes Tavily's [Search](https://docs.tavily.com/documentation/api-reference/endpoint/search), [Extract](https://docs.tavily.com/documentation/api-reference/endpoint/extract), [Crawl](https://docs.tavily.com/documentation/api-reference/endpoint/crawl), and [Map](https://docs.tavily.com/documentation/api-reference/endpoint/map) APIs as Mastra-compatible tools with [Zod](https://zod.dev)-based input/output schemas.

For full reference docs, please refer to the [Mastra documentation](https://docs.mastra.ai/reference/tools/tavily).

## Step-by-Step Integration Guide

### Step 1: Install Required Packages

```bash theme={null}
npm install @mastra/tavily @tavily/core zod
```

### Step 2: Set Up API Keys

* **Tavily API Key:** [Get your Tavily API key here](https://app.tavily.com/home)
* **Anthropic API Key** (or any Mastra-supported provider): [Get an Anthropic API key here](https://console.anthropic.com/)

Set these as environment variables:

```bash theme={null}
export TAVILY_API_KEY=tvly-your-api-key
export ANTHROPIC_API_KEY=your-anthropic-api-key
```

All factory functions read `TAVILY_API_KEY` by default. You can override per tool by passing `{ apiKey }`.

### Step 3: Create Tavily Tools

Use `createTavilyTools()` to get all four tools with shared configuration:

```typescript theme={null}
import { createTavilyTools } from "@mastra/tavily";

const tools = createTavilyTools();
// tools.tavilySearch, tools.tavilyExtract, tools.tavilyCrawl, tools.tavilyMap

// Or with an explicit API key:
const tools = createTavilyTools({ apiKey: "tvly-..." });
```

Each tool can also be created individually when you only need one:

```typescript theme={null}
import {
  createTavilySearchTool,
  createTavilyExtractTool,
} from "@mastra/tavily";

const searchTool = createTavilySearchTool();
const extractTool = createTavilyExtractTool();
```

### Step 4: Wire Tools into a Mastra Agent

```typescript theme={null}
import { Agent } from "@mastra/core/agent";
import {
  createTavilySearchTool,
  createTavilyExtractTool,
} from "@mastra/tavily";

const agent = new Agent({
  id: "web-search-agent",
  name: "Web Search Agent",
  model: "anthropic/claude-sonnet-4-6",
  instructions:
    "You are a web search assistant. Use the search tool to find relevant pages, then use extract to pull full content from the best results.",
  tools: {
    search: createTavilySearchTool(),
    extract: createTavilyExtractTool(),
  },
});
```

## Available Tools

### Tavily Search

Real-time web search.

Tool ID: `tavily-search`.

```typescript theme={null}
import { createTavilySearchTool } from "@mastra/tavily";

const searchTool = createTavilySearchTool();
```

**Key input options:**

* `query` (required) — the search query
* `searchDepth` — `"basic"`, `"advanced"`, `"fast"`, or `"ultra-fast"`
* `maxResults` — 1–20
* `includeAnswer` — `boolean`, `"basic"`, or `"advanced"` for an AI-generated summary
* `includeImages`, `includeImageDescriptions`
* `includeRawContent` — `false`, `"markdown"`, or `"text"`
* `includeDomains`, `excludeDomains` — string arrays
* `timeRange` — `"day"`, `"week"`, `"month"`, or `"year"`

### Tavily Extract

Clean, structured content extraction from one or more URLs (up to 20 per request).

Tool ID: `tavily-extract`.

```typescript theme={null}
import { createTavilyExtractTool } from "@mastra/tavily";

const extractTool = createTavilyExtractTool();
```

**Key input options:**

* `urls` (required) — 1–20 URLs
* `extractDepth` — `"basic"` or `"advanced"` (use `"advanced"` for tables and embedded content)
* `query` — user intent used to rerank extracted chunks
* `includeImages`
* `format` — `"markdown"` (default) or `"text"`

### Tavily Crawl

Crawl a website from a starting URL with configurable depth, breadth, and domain constraints.

Tool ID: `tavily-crawl`.

```typescript theme={null}
import { createTavilyCrawlTool } from "@mastra/tavily";

const crawlTool = createTavilyCrawlTool();
```

**Key input options:**

* `url` (required) — root URL for the crawl
* `maxDepth`, `maxBreadth`, `limit`
* `instructions` — natural-language crawling hints
* `selectPaths`, `selectDomains`, `excludePaths`, `excludeDomains` — regex arrays
* `allowExternal`
* `extractDepth`, `includeImages`, `format`

### Tavily Map

Discover site structure without extracting content — returns a list of URLs.

Tool ID: `tavily-map`.

```typescript theme={null}
import { createTavilyMapTool } from "@mastra/tavily";

const mapTool = createTavilyMapTool();
```

**Key input options:**

* `url` (required) — root URL for the map
* `maxDepth`, `maxBreadth`, `limit`
* `instructions`
* `selectPaths`, `selectDomains`, `excludePaths`, `excludeDomains`
* `allowExternal`

## Configuration

All factory functions accept the same `TavilyClientOptions`:

* `apiKey` — falls back to the `TAVILY_API_KEY` environment variable
* `clientSource` — attribution string sent with each request (defaults to `"mastra"`)
* `apiBaseURL` — override the Tavily API base URL
* `proxies` — proxy configuration for the underlying HTTP client
* `projectId` — Tavily project ID for request scoping

## Using Multiple Tools Together

Combine tools for richer research workflows — for example, map a site first, then crawl the paths you care about:

```typescript theme={null}
import { Agent } from "@mastra/core/agent";
import { createTavilyTools } from "@mastra/tavily";

const tools = createTavilyTools();

const agent = new Agent({
  id: "site-research-agent",
  name: "Site Research Agent",
  model: "anthropic/claude-sonnet-4-6",
  instructions:
    "Given a website, map its structure, pick the most relevant paths, then crawl them and summarize the findings.",
  tools,
});
```

## Environment Variables

| Variable         | Description                                                                                 |
| ---------------- | ------------------------------------------------------------------------------------------- |
| `TAVILY_API_KEY` | Your Tavily API key. Used as the default when `apiKey` is not passed to a factory function. |

## Benefits of Tavily + Mastra

* **First-class tools:** drop-in `createTool()`-compatible factories with Zod input/output schemas.
* **Lazy, cached client:** each tool instantiates `@tavily/core` on first use and reuses it across calls.


# n8n
Source: https://docs.tavily.com/documentation/integrations/n8n

Tavily is now available for no-code integration through n8n.

## Introduction

Integrate Tavily with n8n to enhance your workflows with real-time web search and content extraction—without writing code. With Tavily's powerful search and extraction capabilities, you can seamlessly integrate up-to-date online information into your n8n automations.

<Frame>
  <img alt="n8n" />
</Frame>

## How to set up Tavily with n8n

<AccordionGroup>
  <Accordion title="Step 1: Log in to n8n">
    [Log in](https://n8n.io/) to your n8n account or self-hosted instance.
  </Accordion>

  <Accordion title="Step 2: Create a New Workflow">
    Create a new workflow and select a trigger node to start your automation.
  </Accordion>

  <Accordion title="Step 3: Add Tavily to Your Workflow">
    **Option 1: Add Tavily as a Node**

    In the node library, search for **Tavily**. Add it to your workflow and choose between **Search** or **Extract** actions.

    **Option 2: Add Tavily as a Tool to an AI Agent**

    If you are building an AI agent workflow, you can add Tavily as a tool to your agent. This allows your agent to use Tavily for web search or content extraction as part of its reasoning process.

    **Connection:** Connect your Tavily account by entering your [Tavily API key](https://app.tavily.com/home).

    **Configuration:** Set up your parameters:

    **For Search:**

    * Enter your search `query` (can be manually entered or populated from another node's output)
    * Select a `topic` (`general` or `news`)
    * Choose whether to include raw content or generate an answer
    * Specify domains to include or exclude
    * Set search depth and other optional parameters

    **For Extract:**

    * Enter the URL(s) to extract content from (can be a single URL or multiple URLs from another node's output)
    * Choose extraction type (`basic` or `advanced`)

    **Test:** Run a test to verify your configuration.
  </Accordion>

  <Accordion title="Step 4: Process and Use Tavily Results">
    Utilize the search or extraction results in your workflow:

    * Process data through additional nodes
    * Send information to your CRM, database, or email
    * Generate reports or notifications
    * Feed data into AI models for further processing
  </Accordion>
</AccordionGroup>

## Use cases for Tavily in n8n

Leverage Tavily's capabilities to create powerful automated workflows:

* **Job Search Automation**: Find and summarize new job postings, then send results to your inbox
* **Competitive Intelligence**: Automatically gather and analyze competitor information
* **Market Research**: Track industry trends and market developments
* **Content Curation**: Collect and organize relevant content for your business
* **Lead Enrichment**: Enhance lead data with real-time information
* **News Monitoring**: Stay updated with the latest developments in your field

## Detailed example – Automated job search

Create an automated workflow that uses an AI agent with Tavily as a tool for web search to find new "Software Engineering Intern Roles" on the web, summarizes the results, and sends them to your email.

<Accordion title="Workflow Steps">
  1. **Trigger:** Schedule the workflow to run daily or weekly
  2. **AI Agent:** Add an AI agent node to your workflow
  3. **Add Tavily as a Tool:** In the AI agent configuration, add Tavily as a tool for web search
  4. **Search:** The AI agent uses Tavily to find new "Software Engineering Intern Roles"
  5. **Summarize:** The AI agent summarizes the search results using its LLM capabilities
  6. **Email:** Use the Email node to send the summarized results to your inbox
</Accordion>

## Best practices

To optimize your Tavily integration in n8n:

* Use the SplitInBatches node to process multiple search results efficiently
* Use filters to process only relevant results
* Use the Merge node to combine multiple search results


# OpenAI
Source: https://docs.tavily.com/documentation/integrations/openai

Integrate Tavily with OpenAI to enhance your AI applications with real-time web search capabilities.

## Introduction

This guide shows you how to integrate Tavily with OpenAI to create more powerful and informed AI applications. By combining OpenAI's language models with Tavily's real-time web search capabilities, you can build AI systems and agentic AI applications that access current information and provide up-to-date responses.

## Prerequisites

Before you begin, make sure you have:

* An OpenAI API key from [OpenAI Platform](https://platform.openai.com/)
* A Tavily API key from [Tavily Dashboard](https://app.tavily.com/sign-in)

## Installation

Install the required packages:

```bash theme={null}
pip install openai tavily-python
```

## Setup

Set up your API keys:

```python theme={null}
import os

# Set your API keys
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
os.environ["TAVILY_API_KEY"] = "your-tavily-api-key"
```

## Using Tavily with OpenAI agents SDK

```bash theme={null}
pip install -U openai-agents
```

```python theme={null}
import os
import asyncio
from agents import Agent, Runner, function_tool
from tavily import TavilyClient

tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
```

```python theme={null}
@function_tool
def tavily_search(query: str) -> str:
    """
    Perform a web search using Tavily and return a summarized result.
    """
    response = tavily_client.search(query,search_depth='advanced',max_results='5')
    results = response.get("results", [])
    return results or "No results found."
```

> **Note:** You can enhance the function by adding more parameters like `topic="news"`, `include_domains=["example.com"]`, `time_range="week"`, etc. to customize your search results.

> You can set `auto_parameters=True` to have Tavily automatically configure search parameters based on the content and intent of your query. You can still set other parameters manually, and any explicit values you provide will override the automatic ones.

```python theme={null}
async def main():
    agent = Agent(
        name="Web Research Agent",
        instructions="Use tavily_search when you need up-to-date info.",
        tools=[tavily_search],
    )
    out = await Runner.run(agent, "Latest developments about quantum computing from 2025")
    print(out.final_output)
```

```python theme={null}
asyncio.run(main())
```

<Accordion title="Full Code Example">
  ```python theme={null}

  import os
  import asyncio
  from agents import Agent, Runner, function_tool
  from tavily import TavilyClient

  tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

  @function_tool
  def tavily_search(query: str) -> str:
      """
      Perform a web search using Tavily and return a summarized result.
      """
      response = tavily_client.search(query,search_depth='advanced',max_results='5')
      results = response.get("results", [])
      return results or "No results found."

  async def main():
      agent = Agent(
          name="Web Research Agent",
          instructions="Use tavily_search when you need up-to-date info.",
          tools=[tavily_search],
      )
      out = await Runner.run(agent, "Latest developments about quantum computing from 2025")
      print(out.final_output)


  asyncio.run(main())
  ```
</Accordion>

## Using Tavily with OpenAI Chat Completions API function calling

```python theme={null}
import os
import json
from tavily import TavilyClient
from openai import OpenAI

# Load your API keys from environment variables
tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
openai_client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
```

### Function definition

Define a function that OpenAI can call to perform searches:

```python theme={null}
def tavily_search(**kwargs):
    # Pass ALL supported kwargs straight to Tavily
    results = tavily_client.search(**kwargs)
    return results
```

```python theme={null}
# --- define tools ---
tools = [
    {
        "type": "function",
        "function": {
            "name": "tavily_search",
            "description": "Search the web with Tavily for up-to-date information",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "The search query"},
                    "max_results": {"type": "integer", "default": 5},
                },
                "required": ["query"],
            },
        },
    }
]
```

[Scroll to the bottom to find the full json schema for search, extract, map and crawl](#tavily-endpoints-schema-for-openai-responses-api-tool-definition)

```python theme={null}
# --- conversation ---
messages = [
    {"role": "system", "content": "You are a helpful assistant that uses Tavily search when needed."},
    {"role": "user", "content": "What are the top trends in 2025 about AI agents?"}
]
```

```python theme={null}
#Ask the model; let it decide whether to call the tool
response = openai_client.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages,
    tools=tools,
)
```

```python theme={null}
assistant_msg = response.choices[0].message
 # keep the assistant msg that requested tool(s)
messages.append(assistant_msg) 
```

```python theme={null}

if getattr(assistant_msg, "tool_calls", None):
    for tc in assistant_msg.tool_calls:
        args = tc.function.arguments
        if isinstance(args, str):
            args = json.loads(args)
        elif not isinstance(args, dict):
            args = json.loads(str(args))

        if tc.function.name == "tavily_search":
            # forward ALL args
            results = tavily_search(**args)

            messages.append({
                "role": "tool",
                "tool_call_id": tc.id,
                "name": "tavily_search",
                "content": json.dumps(results),
            })
else:
    print("\nNo tool call requested by the model.")

```

```python theme={null}
# Ask the model again for the final grounded answer
final = openai_client.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages,
)

final_msg = final.choices[0].message
print("\nFINAL ANSWER:\n", final_msg.content or "(no content)")
```

<Accordion title="Full Code Example">
  ```python theme={null}
  import os
  import json
  from tavily import TavilyClient
  from openai import OpenAI

  # --- setup ---
  tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
  openai_client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

  def tavily_search(**kwargs):
      # Pass ALL supported kwargs straight to Tavily
      results = tavily_client.search(**kwargs)
      return results

  # --- define tools ---
  tools = [
      {
          "type": "function",
          "function": {
              "name": "tavily_search",
              "description": "Search the web with Tavily for up-to-date information",
              "parameters": {
                  "type": "object",
                  "properties": {
                      "query": {"type": "string", "description": "The search query"},
                      "max_results": {"type": "integer", "default": 5},
                  },
                  "required": ["query"],
              },
          },
      }
  ]


  # --- conversation ---
  messages = [
      {"role": "system", "content": "You are a helpful assistant that uses Tavily search when needed."},
      {"role": "user", "content": "What are the top trends in 2025 about AI agents?"}
  ]


  #Ask the model; let it decide whether to call the tool
  response = openai_client.chat.completions.create(
      model="gpt-4o-mini",
      messages=messages,
      tools=tools,
  )

  assistant_msg = response.choices[0].message
  messages.append(assistant_msg)  # keep the assistant msg that requested tool(s)

  if getattr(assistant_msg, "tool_calls", None):
      for tc in assistant_msg.tool_calls:
          args = tc.function.arguments
          if isinstance(args, str):
              args = json.loads(args)
          elif not isinstance(args, dict):
              args = json.loads(str(args))

          if tc.function.name == "tavily_search":
              # forward ALL args
              results = tavily_search(**args)

              messages.append({
                  "role": "tool",
                  "tool_call_id": tc.id,
                  "name": "tavily_search",
                  "content": json.dumps(results),
              })
  else:
      print("\nNo tool call requested by the model.")

  # Ask the model again for the final grounded answer
  final = openai_client.chat.completions.create(
      model="gpt-4o-mini",
      messages=messages,
  )

  final_msg = final.choices[0].message
  print("\nFINAL ANSWER:\n", final_msg.content or "(no content)")
  ```
</Accordion>

## Using Tavily with OpenAI Responses API function calling

```python theme={null}
import os
import json
from tavily import TavilyClient
from openai import OpenAI

# --- setup ---
tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
openai_client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
```

### Function definition

Define a function that OpenAI can call to perform searches:

```python theme={null}
# --- Function that will be called when AI requests a search ---
def tavily_search(**kwargs):
    """
    Execute a Tavily web search with the given parameters.
    This function is called by the AI when it needs to search the web.
    """
    results = tavily_client.search(**kwargs)
    return results
```

```python theme={null}
# Define the tool for Tavily web search
# This tells the AI what function it can call and what parameters it needs
tools = [{
    "type": "function",
    "name": "tavily_search",
    "description": "Search the web using Tavily. Provide relevant links in your answer.",
    "parameters": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "Search query for Tavily."
            },
            "max_results": {
                "type": "integer",
                "description": "Max number of results to return",
                "default": 5
            }
        },
        "required": ["query", "max_results"], 
        "additionalProperties": False
    },
    "strict": True
}]
```

[Scroll to the bottom to find the full json schema for search, extract, map and crawl](#tavily-endpoints-schema-for-openai-responses-api-tool-definition)

```python theme={null}
# --- Step 1: Create initial conversation ---
# This sets up the conversation context for the AI
input_list = [
    {"role": "system", "content": "You are a helpful assistant that uses Tavily search when needed."},
    {"role": "user", "content": "What are the top trends in 2025 about AI agents?"}
]

# --- Step 2: First API call - AI decides to search ---
# The AI will analyze the user's question and decide if it needs to search the web
response = openai_client.responses.create(
    model="gpt-4o-mini",
    tools=tools,
    input=input_list,
)

# --- Step 3: Process the AI's response ---
# Add the AI's response (including any function calls) to our conversation
input_list += response.output
```

```python theme={null}
# --- Step 4: Execute any function calls the AI made ---
for item in response.output:
    if item.type == "function_call":
        if item.name == "tavily_search":
            # Parse the arguments the AI provided for the search
            parsed_args = json.loads(item.arguments)
            
            # Execute the actual Tavily search
            results = tavily_search(**parsed_args)
            
            # Add the search results back to the conversation
            # This tells the AI what it found when it searched
            function_output = {
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps({
                  "results": results
                })
            }
            input_list.append(function_output)

```

```python theme={null}
# --- Step 5: Second API call - AI provides final answer ---
# Now the AI has the search results and can provide an informed response
response = openai_client.responses.create(
    model="gpt-4o-mini",
    instructions="Based on the Tavily search results provided, give me a comprehensive summary with citations.",
    input=input_list,
)

# --- Display the final result ---
print("AI Response:")
print(response.output_text)
```

<Accordion title="Full Code Example">
  ```python theme={null}
  import os
  import json
  from tavily import TavilyClient
  from openai import OpenAI

  # --- Setup: Initialize API clients ---
  tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
  openai_client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

  # --- Function that will be called when AI requests a search ---
  def tavily_search(**kwargs):
      """
      Execute a Tavily web search with the given parameters.
      This function is called by the AI when it needs to search the web.
      """
      results = tavily_client.search(**kwargs)
      return results

  # --- Define the search tool for OpenAI to use ---
  # This tells the AI what function it can call and what parameters it needs
  tools = [{
      "type": "function",
      "name": "tavily_search",
      "description": "Search the web using Tavily. Provide relevant links in your answer.",
      "parameters": {
          "type": "object",
          "properties": {
              "query": {
                  "type": "string",
                  "description": "Search query for Tavily."
              },
              "max_results": {
                  "type": "integer",
                  "description": "Max number of results to return",
                  "default": 5
              }
          },
          "required": ["query", "max_results"], 
          "additionalProperties": False
      },
      "strict": True
  }]


  # --- Step 1: Create initial conversation ---
  # This sets up the conversation context for the AI
  input_list = [
      {"role": "system", "content": "You are a helpful assistant that uses Tavily search when needed."},
      {"role": "user", "content": "What are the top trends in 2025 about AI agents?"}
  ]

  # --- Step 2: First API call - AI decides to search ---
  # The AI will analyze the user's question and decide if it needs to search the web
  response = openai_client.responses.create(
      model="gpt-4o-mini",
      tools=tools,
      input=input_list,
  )

  # --- Step 3: Process the AI's response ---
  # Add the AI's response (including any function calls) to our conversation
  input_list += response.output

  # --- Step 4: Execute any function calls the AI made ---
  for item in response.output:
      if item.type == "function_call":
          if item.name == "tavily_search":
              # Parse the arguments the AI provided for the search
              parsed_args = json.loads(item.arguments)
              
              # Execute the actual Tavily search
              results = tavily_search(**parsed_args)
              
              # Add the search results back to the conversation
              # This tells the AI what it found when it searched
              function_output = {
                  "type": "function_call_output",
                  "call_id": item.call_id,
                  "output": json.dumps({
                    "results": results
                  })
              }
              input_list.append(function_output)

  # --- Step 5: Second API call - AI provides final answer ---
  # Now the AI has the search results and can provide an informed response
  response = openai_client.responses.create(
      model="gpt-4o-mini",
      instructions="Based on the Tavily search results provided, give me a comprehensive summary with citations.",
      input=input_list,
  )

  # --- Display the final result ---
  print("AI Response:")
  print(response.output_text)
  ```
</Accordion>

## Tavily endpoints schema for OpenAI Responses API tool definition

> **Note:** When using these schemas, you can customize which parameters are exposed to the model based on your specific use case. For example, if you are building a finance application, you might set `topic`: `"finance"` for all queries without exposing the `topic` parameter. This way, the LLM can focus on deciding other parameters, such as `time_range`, `country`, and so on, based on the user’s request. Feel free to modify these schemas as needed and only pass the parameters that are relevant to your application.

> **API Format:** The schemas below are for OpenAI Responses API. For Chat Completions API, wrap the parameters in a `"function"` object: `{"type": "function", "function": {"name": "...", "parameters": {...}}}`.

<Accordion title="search schema">
  ```python theme={null}
  tools = [
      {
          "type": "function",
          "name": "tavily_search",
          "description": "A powerful web search tool that provides comprehensive, real-time results using Tavily's AI search engine. Returns relevant web content with customizable parameters for result count, content type, and domain filtering. Ideal for gathering current information, news, and detailed web content analysis.",
          "parameters": {
              "type": "object",
              "additionalProperties": False,
              "required": ["query"],
              "properties": {
                  "query": {
                      "type": "string",
                      "description": "Search query"
                  },
                  "auto_parameters": {
                      "type": "boolean",
                      "default": False,
                      "description": "Auto-tune parameters based on the query. Explicit values you pass still win."
                  },
                  "topic": {
                      "type": "string",
                      "enum": ["general", "news","finance"],
                      "default": "general",
                      "description": "The category of the search. This will determine which of our agents will be used for the search"
                  },
                  "search_depth": {
                      "type": "string",
                      "enum": ["basic", "advanced"],
                      "default": "basic",
                      "description": "The depth of the search. It can be 'basic' or 'advanced'"
                  },
                  "chunks_per_source": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 3,
                      "default": 3,
                      "description": "Chunks are short content snippets (maximum 500 characters each) pulled directly from the source."
                  },
                  "max_results": {
                      "type": "integer",
                      "minimum": 0,
                      "maximum": 20,
                      "default": 5,
                      "description": "The maximum number of search results to return"
                  },
                  "time_range": {
                      "type": "string",
                      "enum": ["day", "week", "month", "year"],
                      "description": "The time range back from the current date to include in the search results. This feature is available for both 'general' and 'news' search topics"
                  },
                  "start_date": {
                      "type": "string",
                      "format": "date",
                      "description": "Will return all results after the specified start date. Required to be written in the format YYYY-MM-DD."
                  },
                  "end_date": {
                      "type": "string",
                      "format": "date",
                      "description": "Will return all results before the specified end date. Required to be written in the format YYYY-MM-DD"
                  },
                  "include_answer": {
                      "description": "Include an LLM-generated answer. 'basic' is brief; 'advanced' is more detailed.",
                      "oneOf": [
                          {"type": "boolean"},
                          {"type": "string", "enum": ["basic", "advanced"]}
                      ],
                      "default": False
                  },
                  "include_raw_content": {
                      "description": "Include the cleaned and parsed HTML content of each search result",
                      "oneOf": [
                          {"type": "boolean"},
                          {"type": "string", "enum": ["markdown", "text"]}
                      ],
                      "default": False
                  },
                  "include_images": {
                      "type": "boolean",
                      "default": False,
                      "description": "Include a list of query-related images in the response"
                  },
                  "include_image_descriptions": {
                      "type": "boolean",
                      "default": False,
                      "description": "Include a list of query-related images and their descriptions in the response"
                  },
                  "include_favicon": {
                      "type": "boolean",
                      "default": False,
                      "description": "Whether to include the favicon URL for each result"
                  },
                  "include_usage": {
                      "type": "boolean",
                      "default": False,
                      "description": "Whether to include credit usage information in the response"
                  },
                  "include_domains": {
                      "type": "array",
                      "items": {"type": "string"},
                      "maxItems": 300,
                      "description": "A list of domains to specifically include in the search results, if the user asks to search on specific sites set this to the domain of the site"
                  },
                  "exclude_domains": {
                      "type": "array",
                      "items": {"type": "string"},
                      "maxItems": 150,
                      "description": "List of domains to specifically exclude, if the user asks to exclude a domain set this to the domain of the site"
                  },
                  "country": {
                      "type": "string",
                      "enum": ["afghanistan", "albania", "algeria", "andorra", "angola", "argentina", "armenia", "australia", "austria", "azerbaijan", "bahamas", "bahrain", "bangladesh", "barbados", "belarus", "belgium", "belize", "benin", "bhutan", "bolivia", "bosnia and herzegovina", "botswana", "brazil", "brunei", "bulgaria", "burkina faso", "burundi", "cambodia", "cameroon", "canada", "cape verde", "central african republic", "chad", "chile", "china", "colombia", "comoros", "congo", "costa rica", "croatia", "cuba", "cyprus", "czech republic", "denmark", "djibouti", "dominican republic", "ecuador", "egypt", "el salvador", "equatorial guinea", "eritrea", "estonia", "ethiopia", "fiji", "finland", "france", "gabon", "gambia", "georgia", "germany", "ghana", "greece", "guatemala", "guinea", "haiti", "honduras", "hungary", "iceland", "india", "indonesia", "iran", "iraq", "ireland", "israel", "italy", "jamaica", "japan", "jordan", "kazakhstan", "kenya", "kuwait", "kyrgyzstan", "latvia", "lebanon", "lesotho", "liberia", "libya", "liechtenstein", "lithuania", "luxembourg", "madagascar", "malawi", "malaysia", "maldives", "mali", "malta", "mauritania", "mauritius", "mexico", "moldova", "monaco", "mongolia", "montenegro", "morocco", "mozambique", "myanmar", "namibia", "nepal", "netherlands", "new zealand", "nicaragua", "niger", "nigeria", "north korea", "north macedonia", "norway", "oman", "pakistan", "panama", "papua new guinea", "paraguay", "peru", "philippines", "poland", "portugal", "qatar", "romania", "russia", "rwanda", "saudi arabia", "senegal", "serbia", "singapore", "slovakia", "slovenia", "somalia", "south africa", "south korea", "south sudan", "spain", "sri lanka", "sudan", "sweden", "switzerland", "syria", "taiwan", "tajikistan", "tanzania", "thailand", "togo", "trinidad and tobago", "tunisia", "turkey", "turkmenistan", "uganda", "ukraine", "united arab emirates", "united kingdom", "united states", "uruguay", "uzbekistan", "venezuela", "vietnam", "yemen", "zambia", "zimbabwe"],
                      "description": "Boost search results from a specific country. This will prioritize content from the selected country in the search results. Available only if topic is general. Country names MUST be written in lowercase, plain English, with spaces and no underscores."
                  }
              }
          }
      }
  ]


  ```
</Accordion>

<Accordion title="extract schema">
  ```python theme={null}
  tools = [
      {
          "type": "function",
          "name": "tavily_extract",
          "description": "A powerful web content extraction tool that retrieves and processes raw content from specified URLs, ideal for data collection, content analysis, and research tasks.",
          "parameters": {
              "type": "object",
              "additionalProperties": False,
              "required": ["urls"],
              "properties": {
                  "urls": {
                      "type": "string",
                      "description": "List of URLs to extract content from"
                  },
                  "include_images": {
                      "type": "boolean",
                      "default": False,
                      "description": "Include a list of images extracted from the urls in the response"
                  },
                  "include_favicon": {
                      "type": "boolean",
                      "default": False,
                      "description": "Whether to include the favicon URL for each result"
                  },
                  "include_usage": {
                      "type": "boolean",
                      "default": False,
                      "description": "Whether to include credit usage information in the response"
                  },
                  "extract_depth": {
                      "type": "string",
                      "enum": ["basic", "advanced"],
                      "default": "basic",
                      "description": "Depth of extraction - 'basic' or 'advanced', if urls are linkedin use 'advanced' or if explicitly told to use advanced"
                  },
                  "timeout": {
                      "type": "number",
                      "enum": ["basic", "advanced"],
                      "minimum": 0,
                      "maximum": 60,
                      "default": None,
                      "description": "Maximum time in seconds to wait for the URL extraction before timing out. Must be between 1.0 and 60.0 seconds. If not specified, default timeouts are applied based on extract_depth: 10 seconds for basic extraction and 30 seconds for advanced extraction"
                  },
                  "format": {
                      "type": "string",
                      "enum": ["markdown", "text"],
                      "default": "markdown",
                      "description": "The format of the extracted web page content. markdown returns content in markdown format. text returns plain text and may increase latency."
                  }
              }
          }
      }
  ]



  ```
</Accordion>

<Accordion title="map schema">
  ```python theme={null}

  tools = [
      {
          "type": "function",
          "name": "tavily_map",
          "description": "A powerful web mapping tool that creates a structured map of website URLs, allowing you to discover and analyze site structure, content organization, and navigation paths. Perfect for site audits, content discovery, and understanding website architecture.",
          "parameters": {
              "type": "object",
              "additionalProperties": False,
              "required": ["url"],
              "properties": {
                  "url": {
                      "type": "string",
                      "description": "The root URL to begin the mapping"
                  },
                  "instructions": {
                      "type": "string",
                      "description": "Natural language instructions for the crawler"
                  },
                  "max_depth": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 5,
                      "default": 1,
                      "description": "Max depth of the mapping. Defines how far from the base URL the crawler can explore"
                  },
                  "max_breadth": {
                      "type": "integer",
                      "minimum": 1,
                      "default": 20,
                      "description": "Max number of links to follow per level of the tree (i.e., per page)"
                  },
                  "limit": {
                      "type": "integer",
                      "minimum": 1,
                      "default": 50,
                      "description": "Total number of links the crawler will process before stopping"
                  },
                  "select_paths": {
                      "type": "array",
                      "items": {"type": "string"},
                      "description": "Regex patterns to select only URLs with specific path patterns (e.g., /docs/.*, /api/v1.*)"
                  },
                  "select_domains": {
                      "type": "array",
                      "items": {"type": "string"},
                      "description": "Regex patterns to select crawling to specific domains or subdomains (e.g., ^docs\\.example\\.com$)"
                  },
                  "exclude_paths": {
                      "type": "array",
                      "items": {"type": "string"},
                      "description": "Regex patterns to exclude URLs with specific path patterns (e.g., /admin/.*)."
                  },
                  "exclude_domains": {
                      "type": "array",
                      "items": {"type": "string"},
                      "description": "Regex patterns to exclude specific domains or subdomains"
                  },
                  "allow_external": {
                      "type": "boolean",
                      "default": True,
                      "description": "Whether to allow following links that go to external domains"
                  },
                  "include_usage": {
                      "type": "boolean",
                      "default": False,
                      "description": "Whether to include credit usage information in the response"
                  }
              }
          }
      }
  ]


  ```
</Accordion>

<Accordion title="crawl schema">
  ```python theme={null}
  tools = [
      {
          "type": "function",
          "name": "tavily_crawl",
          "description": "A powerful web crawler that initiates a structured web crawl starting from a specified base URL. The crawler expands from that point like a tree, following internal links across pages. You can control how deep and wide it goes, and guide it to focus on specific sections of the site.",
          "parameters": {
              "type": "object",
              "additionalProperties": False,
              "required": ["url"],
              "properties": {
                  "url": {
                      "type": "string",
                      "description": "The root URL to begin the crawl"
                  },
                  "instructions": {
                      "type": "string",
                      "description": "Natural language instructions for the crawler"
                  },
                  "max_depth": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 5,
                      "default": 1,
                      "description": "Max depth of the crawl. Defines how far from the base URL the crawler can explore."
                  },
                  "max_breadth": {
                      "type": "integer",
                      "minimum": 1,
                      "default": 20,
                      "description": "Max number of links to follow per level of the tree (i.e., per page)"
                  },
                  "limit": {
                      "type": "integer",
                      "minimum": 1,
                      "default": 50,
                      "description": "Total number of links the crawler will process before stopping"
                  },
                  "select_paths": {
                      "type": "array",
                      "items": {"type": "string"},
                      "description": "Regex patterns to select only URLs with specific path patterns (e.g., /docs/.*, /api/v1.*)"
                  },
                  "select_domains": {
                      "type": "array",
                      "items": {"type": "string"},
                      "description": "Regex patterns to select crawling to specific domains or subdomains (e.g., ^docs\\.example\\.com$)"
                  },
                  "exclude_paths": {
                      "type": "array",
                      "items": {"type": "string"},
                      "description": "Regex patterns to exclude paths (e.g., /private/.*, /admin/.*)"
                  },
                  "exclude_domains": {
                      "type": "array",
                      "items": {"type": "string"},
                      "description": "Regex patterns to exclude domains/subdomains (e.g., ^private\\.example\\.com$)"
                  },
                  "allow_external": {
                      "type": "boolean",
                      "default": True,
                      "description": "Whether to allow following links that go to external domains"
                  },
                  "include_images": {
                      "type": "boolean",
                      "default": False,
                      "description": "Include images discovered during the crawl"
                  },
                  "extract_depth": {
                      "type": "string",
                      "enum": ["basic", "advanced"],
                      "default": "basic",
                      "description": "Advanced extraction retrieves more data, including tables and embedded content, with higher success but may increase latency"
                  },
                  "format": {
                      "type": "string",
                      "enum": ["markdown", "text"],
                      "default": "markdown",
                      "description": "The format of the extracted web page content. markdown returns content in markdown format. text returns plain text and may increase latency."
                  },
                  "include_favicon": {
                      "type": "boolean",
                      "default": False,
                      "description": "Whether to include the favicon URL for each result"
                  },
                  "include_usage": {
                      "type": "boolean",
                      "default": False,
                      "description": "Whether to include credit usage information in the response"
                  }
              }
          }
      }
  ]


  ```
</Accordion>

For more information about Tavily's capabilities, check out our [API documentation](/documentation/api-reference/introduction) and [best practices](/documentation/best-practices/best-practices-search).


# OpenClaw
Source: https://docs.tavily.com/documentation/integrations/openclaw

Integrate Tavily with OpenClaw to give your AI agents real-time web search and content extraction across WhatsApp, Telegram, Discord, iMessage, and more.

## Introduction

[OpenClaw](https://docs.openclaw.ai/) is an open-source, self-hosted gateway that connects messaging apps — WhatsApp, Telegram, Discord, iMessage, and more — to AI agents. You run a single Gateway process on your own machine or server, and it becomes the bridge between your chat apps and an always-available AI assistant.

Tavily is available in OpenClaw as both a web search provider and a dedicated plugin, giving your agents real-time web search and content extraction capabilities across every connected channel. Whether a user asks a question on WhatsApp or shares a link in Telegram, the agent can search the web and extract page content to provide accurate, up-to-date answers.

<Frame>
  <img alt="OpenClaw onboarding with Tavily as the web search provider" />
</Frame>

## How to set up Tavily with OpenClaw

<AccordionGroup>
  <Accordion title="Step 1: Obtain your Tavily API key">
    Go to the [Tavily Dashboard](https://app.tavily.com/home) to obtain your **API key**. Sign up for free if you don't have an account.
  </Accordion>

  <Accordion title="Step 2: Configure Tavily as your search provider">
    You can configure Tavily using the interactive CLI or by editing your config file directly.

    **Option 1: Interactive CLI**

    Run the onboarding wizard and select Tavily when prompted for a search provider:

    ```bash theme={null}
    openclaw configure --section web
    ```

    **Option 2: Manual configuration**

    Add the following to your `~/.openclaw/openclaw.json`:

    ```json theme={null}
    {
      "plugins": {
        "entries": {
          "tavily": {
            "enabled": true,
            "config": {
              "webSearch": {
                "apiKey": "tvly-YOUR_API_KEY"
              }
            }
          }
        }
      },
      "tools": {
        "web": {
          "search": {
            "provider": "tavily"
          }
        }
      }
    }
    ```

    **Option 3: Environment variable**

    Set the `TAVILY_API_KEY` environment variable, or add it to `~/.openclaw/.env`:

    ```bash theme={null}
    export TAVILY_API_KEY="tvly-YOUR_API_KEY"
    ```

    <Tip>
      If `TAVILY_API_KEY` is set and no other search provider key is configured, OpenClaw will auto-detect and select Tavily automatically.
    </Tip>
  </Accordion>

  <Accordion title="Step 3: Start chatting">
    Once configured, your agents can use Tavily across all connected channels. Open the Control UI or send a message from any connected chat app:

    ```bash theme={null}
    openclaw dashboard
    ```
  </Accordion>
</AccordionGroup>

<Tip>
  OpenClaw supports Tavily in two ways: `web_search` uses Tavily as the default web provider for simple searches, while Tavily-native tools like `tavily_search` and `tavily_extract` expose advanced controls such as topic selection, domain filters, search depth, and URL extraction.
</Tip>

## Search modes in OpenClaw

Once Tavily is configured, OpenClaw can use it in two ways.

### 1. `web_search` for simple, provider-backed search

If Tavily is set as your web search provider, OpenClaw's built-in `web_search` tool routes searches through Tavily.

Use this when:

* You want a simple search interface
* Your agent only needs a query and result count
* You want Tavily to power the default OpenClaw web search flow

#### `web_search` parameters

| Parameter | Description                 |
| --------- | --------------------------- |
| `query`   | Search query                |
| `count`   | Number of results to return |

### 2. Tavily-native tools for advanced controls

Use Tavily-native tools when you need Tavily-specific capabilities beyond the generic `web_search` interface.

| Tool             | Use when you need                                                                                 |
| ---------------- | ------------------------------------------------------------------------------------------------- |
| `tavily_search`  | Search depth, topic filtering, domain includes/excludes, recency filters, or AI-generated answers |
| `tavily_extract` | Clean extraction from one or more URLs                                                            |

#### `tavily_search` parameters

| Parameter         | Description                                               |
| ----------------- | --------------------------------------------------------- |
| `query`           | Search query (keep under 400 characters)                  |
| `search_depth`    | `basic` (default, fast) or `advanced` (highest relevance) |
| `topic`           | `general` (default), `news`, or `finance`                 |
| `max_results`     | Number of results, 1–20 (default: 5)                      |
| `include_answer`  | Include an AI-generated answer summary                    |
| `time_range`      | Filter by recency: `day`, `week`, `month`, or `year`      |
| `include_domains` | Array of domains to restrict results to                   |
| `exclude_domains` | Array of domains to exclude                               |

#### `tavily_extract` parameters

| Parameter           | Description                                          |
| ------------------- | ---------------------------------------------------- |
| `urls`              | Array of URLs to extract (1–20 per request)          |
| `query`             | Rerank extracted chunks by relevance to this query   |
| `extract_depth`     | `basic` (default) or `advanced` (for JS-heavy pages) |
| `chunks_per_source` | Chunks per URL, 1–5 (requires `query`)               |
| `include_images`    | Include image URLs in results                        |

## Use cases

Leverage Tavily through OpenClaw to enhance your AI assistant across every messaging channel:

* **Research on the go** — Ask your agent on WhatsApp to research a topic and get a summarized answer with sources
* **Link analysis** — Share a URL in Telegram and have the agent extract and summarize its content
* **News monitoring** — Use `tavily_search` with `topic: "news"` and `time_range: "day"` to set up heartbeat alerts and get daily updates via your preferred channels
* **Competitive intelligence** — Run domain-filtered searches from any channel to track competitor activity
* **Content curation** — Gather and organize information from multiple sources for reports or newsletters

## Learn more

* [OpenClaw documentation](https://docs.openclaw.ai/)
* [OpenClaw Tavily plugin docs](https://docs.openclaw.ai/tools/tavily)
* [OpenClaw Web Search overview](https://docs.openclaw.ai/tools/web)
* [OpenClaw on GitHub](https://github.com/openclaw/openclaw)
* [Tavily API documentation](/documentation/api-reference/introduction)


# Pydantic AI
Source: https://docs.tavily.com/documentation/integrations/pydantic-ai

Tavily is now available for integration through Pydantic AI.

## Introduction

Integrate[Tavily with Pydantic AI](https://ai.pydantic.dev/common-tools/#tavily-search-tool) to enhance your AI agents with powerful web search capabilities. Pydantic AI provides a framework for building AI agents with tools, making it easy to incorporate real-time web search and data extraction into your applications.

## Step-by-Step Integration Guide

### Step 1: Install Required Packages

Install the necessary Python packages:

```bash theme={null}
pip install "pydantic-ai-slim[tavily]"
```

### Step 2: Set Up API Keys

* **Tavily API Key:** [Get your Tavily API key here](https://app.tavily.com/home)

Set this as an environment variable in your terminal or add it to your environment configuration file:

```bash theme={null}
export TAVILY_API_KEY=your_tavily_api_key
```

### Step 3: Initialize Pydantic AI Agent with Tavily Tools

```python theme={null}
import os
from pydantic_ai.agent import Agent
from pydantic_ai.common_tools.tavily import tavily_search_tool

# Get API key from environment
api_key = os.getenv('TAVILY_API_KEY')
assert api_key is not None

# Initialize the agent with Tavily tools
agent = Agent(
    'openai:o3-mini',
    tools=[tavily_search_tool(api_key)],
    system_prompt='Search Tavily for the given query and return the results.'
)
```

### Step 4: Example Use Cases

```python theme={null}
# Example 1: Basic search for news
result = agent.run_sync('Tell me the top news in the GenAI world, give me links.')
print(result.output)
```

Example Response:

```markdown theme={null}
Here are some of the top recent news articles related to GenAI:

1. How CLEAR users can improve risk analysis with GenAI – Thomson Reuters
   Read more: https://legal.thomsonreuters.com/blog/how-clear-users-can-improve-risk-analysis-with-genai/
   (This article discusses how CLEAR's new GenAI-powered tool streamlines risk analysis by quickly summarizing key information from various public data sources.)

2. TELUS Digital Survey Reveals Enterprise Employees Are Entering Sensitive Data Into AI Assistants More Than You Think – FT.com
   Read more: https://markets.ft.com/data/announce/detail?dockey=600-202502260645BIZWIRE_USPRX____20250226_BW490609-1
   (This news piece highlights findings from a TELUS Digital survey showing that many enterprise employees use public GenAI tools and sometimes even enter sensitive data.)

3. The Essential Guide to Generative AI – Virtualization Review
   Read more: https://virtualizationreview.com/Whitepapers/2025/02/SNOWFLAKE-The-Essential-Guide-to-Generative-AI.aspx
   (This guide provides insights into how GenAI is revolutionizing enterprise strategies and productivity, with input from industry leaders.)
```

## Additional Use Cases

1. **Content Curation**: Gather and organize information from multiple sources
2. **Real-time Data Integration**: Keep your AI agents up-to-date with the latest information
3. **Technical Documentation**: Search and analyze technical documentation
4. **Market Analysis**: Conduct comprehensive market research and analysis


# StackAI
Source: https://docs.tavily.com/documentation/integrations/stackai

Using Tavily in StackAI to enhance your AI workflows with real-time web data.

## Introduction

Integrate [Tavily with StackAI](https://www.stack-ai.com/integrations/tavily) to enhance your AI workflows with real-time web data. With this integration, you can easily fetch and utilize live web content in your StackAI workflows.

<Frame>
  <img alt="stackai" />
</Frame>

## How to set up Tavily with StackAI

<AccordionGroup>
  <Accordion title="Step 1: Log in to StackAI">
    [Log in](https://stack-ai.com/) to your StackAI account or self-hosted instance.
  </Accordion>

  <Accordion title="Step 2: Create a New Workflow">
    Create a new workflow or choose one of the available templates.
  </Accordion>

  <Accordion title="Step 3: Add Tavily to Your Workflow">
    **Option 1: Add Tavily as a Node**

    * Search for "Tavily" under the **Apps** section in the left sidebar.
    * Drag and drop the "Tavily" app into your canvas.

    **Option 2: Add Tavily as a Tool to an AI Agent**

    * Choose between "Search", "Crawl", "Extract" or "Map" tool based on your needs.

    **Configure the Tavily Node or Tool:**

    * In the Connect Tavily section, create a new connection by entering a connection name and your [Tavily API key](https://app.tavily.com/home).

    **Configuring parameters:**

    **For Search:**

    * Enter your search `query` (can be manually entered or populated from another node's output)
    * Select a `topic` (`general` or `news`)
    * Choose whether to include raw content or generate an answer
    * Specify Maximum Search Results to return
    * Set search depth and other optional parameters

    **For Extract:**

    * Enter the URL(s) to extract content from (can be a single URL or multiple URLs from another node's output)
    * Choose Extract Depth (`basic` or `advanced`)
    * Specify the output format (`markdown` or `text`)

    **For Crawl:**

    * Enter the **Root URL** to crawl
    * Set the crawl instructions to guide the crawler
    * Set the Limit on the number of pages to crawl

    **For Map:**

    * Enter the **Root URL** to begin the mapping
    * Set the map instructions to guide the mapping process
    * Set the mapping depth to control how deep the mapping goes

    **Test:** Run the node to verify your configuration.
  </Accordion>

  <Accordion title="Step 4: Process and Use Tavily Results">
    Utilize the search, crawl, extract, or map results in your workflow:

    * Process data through additional nodes
    * Send information to your CRM, database, or email
    * Generate reports or notifications
    * Feed data into AI models for further processing
  </Accordion>
</AccordionGroup>

## Use cases for Tavily in StackAI

Leverage Tavily's capabilities to create powerful automated workflows:

* **Job Search Automation**: Find and summarize new job postings, then send results to your inbox
* **Competitive Intelligence**: Automatically gather and analyze competitor information
* **Market Research**: Track industry trends and market developments
* **Content Curation**: Collect and organize relevant content for your business
* **Lead Enrichment**: Enhance lead data with real-time information
* **News Monitoring**: Stay updated with the latest developments in your field

## Detailed example - AI News Summary

Here's an example workflow that uses Tavily to search for the latest articles on "AI advancements" and sends a summary to your email:

<AccordionGroup>
  <Accordion title="Workflow Steps">
    1. **Trigger:** Schedule the workflow to run daily
    2. **AI Agent:** Add an AI agent node to your workflow
    3. **Search:** The AI agent uses Tavily to find recent articles on "AI advancements"
    4. **Summarize:** The AI agent summarizes the most important news and trends
    5. **Delivery:** Send the summarized briefing via Email, Slack, or another integration
  </Accordion>
</AccordionGroup>

## Best practices

To optimize your Tavily integration in StackAI:

* Tightly constrain Tavily queries to specific intent, time range, and domains to avoid noisy retrieval.
* Force concise, structured outputs (bullets/JSON with only required fields) to reduce tokens and parsing errors.


# Tines
Source: https://docs.tavily.com/documentation/integrations/tines

Integrate Tavily with Tines for automated, no-code intelligence workflows.

## Introduction

Integrate [Tavily with Tines](https://www.tines.com/docs/credentials/connect-flows/tavily/) to enhance your automation workflows with powerful web search and content extraction capabilities. Tines' no-code platform makes it easy to incorporate Tavily's real-time search and data extraction features into your stories, enabling you to build powerful automation workflows without writing code.

## How to set up Tavily with Tines

<AccordionGroup>
  <Accordion title="Step 1: Log in to Tines">
    [Log in](https://www.tines.com/) to your Tines account.
  </Accordion>

  <Accordion title="Step 2: Create or Open a Story">
    Create a new story or open an existing one where you want to add Tavily.
  </Accordion>

  <Accordion title="Step 3: Add a Tavily Action">
    Follow these steps to add a Tavily action to your story:

    1. Navigate to the Templates section.
    2. Search for "Tavily" in the search bar.
    3. Drag the Tavily action into your story.
    4. Select a template between "Extract Web Content" and "Search the Web" based on your use case.
    5. Click on the Tavily connection to set up new credentials.
    6. Enter your Tavily API key in the provided field.
  </Accordion>

  <Accordion title="Step 4: Process and Use Tavily Results">
    Use Tines built-in actions to process Tavily's response:

    * Parse and filter search results
    * Enrich alerts or tickets with real-time intelligence
    * Trigger notifications or follow-up actions based on findings
  </Accordion>
</AccordionGroup>

## Use cases for Tavily in Tines

* **Workbench Integration**: Connect Tavily to Tines Workbench (AI-powered chat interface) to enable real-time web search and content extraction directly in your conversations
* **Market & News Monitoring**: Track industry trends or breaking news relevant to your organization
* **Lead & Entity Enrichment**: Pull real-time data on companies, people, or technologies
* **Content Extraction**: Extract and analyze web content for deeper investigations

## Example Use Cases

<AccordionGroup>
  <Accordion title="Enrich new Airtable company records using Tavily search">
    Enrich a company when it is added to an Airtable database. Receive a webhook notification when a new record is added and fill out the remaining fields with web searches powered by Tavily.

    See the [full story](https://www.tines.com/library/stories/1312477/?name=enrich-new-airtable-company-records-using-tavily-searches) on Tines' library.
  </Accordion>

  <Accordion title="Search the internet with Tavily via Slack">
    Search the internet using Tavily in response to a Slack slash command. Summarize the results and post them in a Slack thread, including source links. Users can click on the links to access more detailed information from the original sources.

    See the [full story](https://www.tines.com/library/stories/1312847/?name=search-the-internet-with-tavily-via-slack) on Tines' library.
  </Accordion>
</AccordionGroup>


# Vellum
Source: https://docs.tavily.com/documentation/integrations/vellum

Use Tavily as the built-in web search provider in the Vellum Assistant desktop app.

<Frame>
  <img alt="Vellum Assistant with Tavily" />
</Frame>

## Introduction

[Vellum Assistant](https://www.vellum.ai/) is a desktop AI assistant from Vellum. It ships with a built-in web search feature that connects your conversations to real-time information from the web, and Tavily is available as one of the supported search providers.

Once configured, Vellum Assistant routes web search queries through the Tavily API so the model can answer questions with up-to-date, agent-optimized results.

## Prerequisites

* The Vellum Assistant desktop app installed on macOS.
* A [Tavily API key](https://app.tavily.com/home).

## Configure Tavily in Vellum Assistant

<Frame>
  <img alt="Vellum Settings" />
</Frame>

<Steps>
  <Step title="Open Vellum Assistant settings">
    Launch Vellum Assistant and open **Settings → Models & Services**.
  </Step>

  <Step title="Add your Tavily API key">
    Find the **Web Search** section, choose **Tavily** as the provider, and paste your Tavily API key into the key field. Vellum Assistant stores the key securely in the system keychain.
  </Step>

  <Step title="Use web search in a conversation">
    Start a new conversation and ask a question that needs current information. Vellum Assistant will call Tavily under the hood and feed the results back to the model.
  </Step>
</Steps>

## Best practices

* **Pick Tavily when you want agent-optimized results** — Tavily returns relevance-scored, LLM-friendly snippets that work especially well inside an assistant flow.
* **Keep one Tavily key per workspace** — using the same key across your tools keeps usage and billing in one place on the [Tavily dashboard](https://app.tavily.com/home).

## Resources

* [Vellum docs](https://www.vellum.ai/docs/)
* [Tavily API dashboard](https://app.tavily.com/home)


# Vercel AI SDK
Source: https://docs.tavily.com/documentation/integrations/vercel

Integrate Tavily with Vercel AI SDK to enhance your AI agents with powerful web search, content extraction, crawling, and site mapping capabilities.

## Introduction

The `@tavily/ai-sdk` package provides pre-built AI SDK tools for Vercel's AI SDK v5, making it easy to add real-time web search, content extraction, intelligent crawling, and site mapping to your AI applications.

## Step-by-Step Integration Guide

### Step 1: Install Required Packages

Install the necessary packages:

```bash theme={null}
npm install ai @ai-sdk/openai @tavily/ai-sdk
```

### Step 2: Set Up API Keys

* **Tavily API Key:** [Get your Tavily API key here](https://app.tavily.com/home)
* **OpenAI API Key:** [Get your OpenAI API key here](https://platform.openai.com/account/api-keys)

Set these as environment variables:

```bash theme={null}
export TAVILY_API_KEY=tvly-your-api-key
export OPENAI_API_KEY=your-openai-api-key
```

### Step 3: Basic Usage

The simplest way to get started with Tavily Search:

```typescript theme={null}
import { tavilySearch } from "@tavily/ai-sdk";
import { generateText, stepCountIs } from "ai";
import { openai } from "@ai-sdk/openai";

const result = await generateText({
  model: openai("gpt-5-mini"),
  prompt: "What are the latest developments in quantum computing?",
  tools: {
    tavilySearch: tavilySearch(),
  },
  stopWhen: stepCountIs(3),
});

console.log(result.text);
```

## Available Tools

### Tavily Search

Real-time web search optimized for AI applications:

```typescript theme={null}
import { tavilySearch } from "@tavily/ai-sdk";
import { generateText, stepCountIs } from "ai";
import { openai } from "@ai-sdk/openai";

const result = await generateText({
  model: openai("gpt-5-mini"),
  prompt: "Research the latest trends in renewable energy technology",
  tools: {
    tavilySearch: tavilySearch({
      searchDepth: "advanced",
      includeAnswer: true,
      maxResults: 5,
      topic: "general",
    }),
  },
  stopWhen: stepCountIs(3),
});
```

**Key Configuration Options:**

* `searchDepth?: "basic" | "advanced"` - Search depth (default: "basic")
* `topic?: "general" | "news" | "finance"` - Search category
* `includeAnswer?: boolean` - Include AI-generated answer
* `maxResults?: number` - Maximum results to return (default: 5)
* `includeImages?: boolean` - Include images in results
* `timeRange?: "year" | "month" | "week" | "day"` - Time range for results
* `includeDomains?: string[]` - Domains to include
* `excludeDomains?: string[]` - Domains to exclude

### Tavily Extract

Clean, structured content extraction from URLs:

```typescript theme={null}
import { tavilyExtract } from "@tavily/ai-sdk";
import { generateText } from "ai";
import { openai } from "@ai-sdk/openai";

const result = await generateText({
  model: openai("gpt-5-mini"),
  prompt: "Extract and summarize the content from https://tavily.com",
  tools: {
    tavilyExtract: tavilyExtract(),
  },
});
```

**Key Configuration Options:**

* `extractDepth?: "basic" | "advanced"` - Extraction depth
* `format?: "markdown" | "text"` - Output format (default: "markdown")
* `includeImages?: boolean` - Include images in extracted content

### Tavily Crawl

Intelligent website crawling at scale:

```typescript theme={null}
import { tavilyCrawl } from "@tavily/ai-sdk";
import { generateText } from "ai";
import { openai } from "@ai-sdk/openai";

const result = await generateText({
  model: openai("gpt-5-mini"),
  prompt: "Crawl tavily.com and tell me about their integrations",
  tools: {
    tavilyCrawl: tavilyCrawl({
      maxDepth: 2,
      limit: 50,
    }),
  },
});
```

**Key Configuration Options:**

* `maxDepth?: number` - Maximum crawl depth (1-5, default: 1)
* `maxBreadth?: number` - Maximum pages per depth level (1-100, default: 20)
* `limit?: number` - Maximum total pages to crawl (default: 50)
* `extractDepth?: "basic" | "advanced"` - Content extraction depth
* `instructions?: string` - Natural language crawling instructions
* `selectPaths?: string[]` - Path patterns to include
* `excludePaths?: string[]` - Path patterns to exclude
* `allowExternal?: boolean` - Allow crawling external domains

### Tavily Map

Website structure discovery and mapping:

```typescript theme={null}
import { tavilyMap } from "@tavily/ai-sdk";
import { generateText, stepCountIs } from "ai";
import { openai } from "@ai-sdk/openai";

const result = await generateText({
  model: openai("gpt-5-mini"),
  prompt: "Map the structure of tavily.com",
  tools: {
    tavilyMap: tavilyMap(),
  },
  stopWhen: stepCountIs(3),
});
```

**Key Configuration Options:**

* `maxDepth?: number` - Maximum mapping depth (1-5, default: 1)
* `maxBreadth?: number` - Maximum pages per depth level (1-100, default: 20)
* `limit?: number` - Maximum total pages to map (default: 50)
* `instructions?: string` - Natural language mapping instructions
* `selectPaths?: string[]` - Path patterns to include
* `excludePaths?: string[]` - Path patterns to exclude
* `allowExternal?: boolean` - Allow mapping external domains

## Using Multiple Tools Together

You can combine multiple Tavily tools in a single AI agent for comprehensive research capabilities:

```typescript theme={null}
import { 
  tavilySearch, 
  tavilyExtract, 
  tavilyCrawl, 
  tavilyMap 
} from "@tavily/ai-sdk";
import { generateText, stepCountIs } from "ai";
import { openai } from "@ai-sdk/openai";

const result = await generateText({
  model: openai("gpt-5-mini"),
  prompt: "Research the company at tavily.com - search for news, map their site, and extract key pages",
  tools: {
    tavilySearch: tavilySearch({ searchDepth: "advanced" }),
    tavilyExtract: tavilyExtract(),
    tavilyCrawl: tavilyCrawl(),
    tavilyMap: tavilyMap(),
  },
  stopWhen: stepCountIs(5),
});
```

## Advanced Examples

### News Research with Time Range

```typescript theme={null}
const newsResult = await generateText({
  model: openai("gpt-5-mini"),
  prompt: "What are the top technology news stories from this week?",
  tools: {
    tavilySearch: tavilySearch({
      topic: "news",
      timeRange: "week",
      maxResults: 10,
    }),
  },
  stopWhen: stepCountIs(3),
});
```

### Market Analysis with Advanced Search

```typescript theme={null}
const marketResult = await generateText({
  model: openai("gpt-5-mini"),
  prompt: "Analyze the current state of the electric vehicle market",
  tools: {
    tavilySearch: tavilySearch({
      searchDepth: "advanced",
      topic: "finance",
      includeAnswer: true,
      maxResults: 10,
    }),
  },
  stopWhen: stepCountIs(5),
});
```

## Benefits of Tavily + Vercel AI SDK

* **Pre-built Tools:** No need to manually create tool definitions - just import and use
* **Type-Safe:** Full TypeScript support with proper type definitions
* **Real-time Information:** Access up-to-date web content for your AI agents
* **Optimized for LLMs:** Search results are specifically formatted for language models
* **Multiple Capabilities:** Search, extract, crawl, and map websites - all in one package
* **Easy Integration:** Works seamlessly with Vercel AI SDK v5
* **Flexible Configuration:** Extensive configuration options for all tools
* **Production-Ready:** Built on the reliable Tavily API infrastructure


# Zapier
Source: https://docs.tavily.com/documentation/integrations/zapier

 Tavily is now available for no-code integration through Zapier.

## Introduction

No need to write a single line of code to connect Tavily to your business processes. With Tavily's robust search capabilities, you can pull in the latest online information into any application or workflow.

Simply set up [**Tavily in Zapier**](https://zapier.com/apps/tavily/integrations) to automate research, track real-time news, or feed relevant data into your tools of choice.

## How to set up Tavily with Zapier

<AccordionGroup>
  <Accordion title="Step 1: Log in to Zapier">
    [Log in](https://zapier.com/sign-up) to your Zapier account.
  </Accordion>

  <Accordion title="Step 2: Create a Zap and Select a Trigger Event">
    Create a new Zap and select a trigger event that will start your workflow.
  </Accordion>

  <Accordion title="Step 3: Add an Action Step with Tavily">
    Add an action step with Tavily in your workflow:

    * **Setup:** Connect your Tavily account by pasting your API key.
    * **Configure:** Enter your search `query` along with optional parameters, such as selecting a `topic` (`general` or `news`), deciding whether to include raw content from the sources or an answer based on the content found, and specifying particular domains to run the search on.
    * **Test:** Test your query.
  </Accordion>

  <Accordion title="Step 4: Use the Results and Answer Generated by Tavily">
    Use the `results` and optionally the `answer` generated by Tavily in the rest of your workflow, such as:

    * Sending up-to-date research to your CRM.
    * Feeding real-time content into your language model (e.g., GPT models) for additional applications.
    * Inserting dynamic info into an email automation tool.
  </Accordion>
</AccordionGroup>

## Use cases for Tavily in Zapier

With Tavily, you can harness the power of Retrieval-Augmented Generation (RAG) to create complex workflows. Here are some examples, for inspiration:

* **Automated Email Generation**: Use Tavily to create tailored emails based on real-time data.

* **Meeting Preparation**: Gather real-time information about meeting participants. For instance, before a client meeting, retrieve their latest news or social media updates and receive a concise summary through your preferred method, ensuring you’re well-informed.

* **Automated Reporting**: Utilize Tavily’s online search data to generate reports. Push this information into tools like **Google Sheets**, **Notion**, or **Slack** to create a weekly digest of industry trends or competitor analysis, keeping your team updated effortlessly.

## Detailed example - company research

We can build an automated workflow that executes brief company research for newly signed-up companies and delivers the report via Slack.

<Accordion title="Workflow Steps">
  1. **Trigger Event:** A new company is created in your CRM.
  2. **Conduct Company Search:** Use Tavily to perform a general search using the company's domain (provided by the CRM).
  3. **Retrieve Current Date:** Capture the current date and pass it to the LLM in the next step.
  4. **Generate Search Queries:** Request the LLM to create 3 concise search queries for Tavily to obtain additional information about the company (e.g., industry, ARR, CEO, CTO). Include the previously gathered data from the company website as context to prevent redundancy. Ask the LLM to incorporate important keywords related to the company to avoid retrieving information about a different company with the same name but in a different industry or domain.
  5. **Organize Queries:** Format the generated queries into separate fields for use in distinct steps.
  6. **Configure Queries:** Set up the 3 queries in Tavily across 3 individual steps.
  7. **Extract Structured Data:** Instruct the LLM to fill in specific details about the company from the gathered data and indicate the sources used for verification. Additionally, instruct the LLM to use the sources extracted from the domain as the ground truth.
  8. **Refine Information:** Format the information for clarity and professionalism.
  9. **Send to Slack:** Deliver the final message to Slack for easy access and sharing.

  <Frame>
    <img alt="zap" />
  </Frame>
</Accordion>

## Best practices

To use Tavily most efficiently in your Zapier workflows, keep the following guidelines in mind when designing your automations:

* Create concise queries for Tavily, and if needed, create multiple Tavily steps.
* If up-to-date news information is required, configure "news" as your topic.
* Add the current date to your queries for relevant, updated information.
* Consider using specific domains to narrow down search results.
* Use an LLM to generate queries for Tavily to enable a more agentic workflow.


# Try Tavily Without an API Key
Source: https://docs.tavily.com/documentation/keyless

Use Tavily Search and Extract with zero setup. No account, no API key, no configuration. Keyless responses are identical to keyed responses.

Drop Tavily into an agent or script in seconds. When you're ready for production, swap in an API key. No code changes required.

## Why Tavily?

Tavily is an AI search engine optimized for agent consumption. Built-in tools like `web_search` and `web_fetch` return raw HTML or shallow snippets, so your agent spends tokens parsing, filtering, and guessing what's relevant. Tavily Search returns clean, ranked, and scored results optimized for LLM consumption. Tavily Extract pulls structured content from any URL without dealing with JavaScript rendering or HTML cleanup. The result: fewer tokens, better context, more reliable agent behavior.

Use Tavily Search and Extract with zero setup. No account, no API key, no configuration. Your agent gets real results immediately and can upgrade to an API key whenever you need higher limits.

<Info>
  **Same results, same schema.** Keyless responses are identical to keyed responses. Your agent can't tell the difference on success.
</Info>

## Direct API

Send a request with the `X-Tavily-Access-Mode: keyless` header. That's it.

<CodeGroup>
  ```bash Search theme={null}
  curl -X POST https://api.tavily.com/search \
    -H "Content-Type: application/json" \
    -H "X-Tavily-Access-Mode: keyless" \
    -d '{"query": "latest AI news", "max_results": 3}'
  ```

  ```bash Extract theme={null}
  curl -X POST https://api.tavily.com/extract \
    -H "Content-Type: application/json" \
    -H "X-Tavily-Access-Mode: keyless" \
    -d '{"urls": ["https://www.tavily.com"]}'
  ```
</CodeGroup>

The response follows the standard Tavily response schema. See the [API Reference](/documentation/api-reference/endpoint/search) for details.

## MCP Server

Connect to the [Tavily Remote MCP](/documentation/mcp) without an API key. Your agent gets `tavily-search` and `tavily-extract` tools with zero configuration.

```bash Claude Code theme={null}
claude mcp add tavily-remote-mcp --transport http https://mcp.tavily.com/mcp/
```

### Agent-installable prompt

Paste this into any AI assistant to let it set up Tavily itself:

```text theme={null}
Set up the Tavily MCP server so you can search the web and extract content from URLs. Follow these steps:

1. Detect which platform you're running on (Claude Code, Cursor, Windsurf, Claude Desktop, etc.)
2. Install the Tavily MCP server using the correct method for your platform:
   - Server URL: https://mcp.tavily.com/mcp/
   - Transport: Streamable HTTP
   - Authentication: none required. Tavily is free to use without an API key.
3. Verify the server is connected and you have access to the tavily-search and tavily-extract tools.
4. Run a test search (e.g. "current weather in Tel Aviv") to confirm you get real results from a live source.
5. Report back whether setup succeeded.
```

## Supported endpoints

| Endpoint   | Keyless | Notes                           |
| ---------- | ------- | ------------------------------- |
| `/search`  | Yes     | Full search with all parameters |
| `/extract` | Yes     | Content extraction from URLs    |

## Rate limits

Keyless access has rate limits. If you hit a limit, [sign up](https://app.tavily.com) for a free API key (1,000 credits/month, no credit card required) and pass it as a Bearer token:

```bash theme={null}
curl -X POST https://api.tavily.com/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer tvly-YOUR_API_KEY" \
  -d '{"query": "latest AI news"}'
```

<Info>
  When you hit a limit, Tavily returns natural-language instructions telling your agent what happened and how to continue.
</Info>

## FAQ

<AccordionGroup>
  <Accordion title="Do keyless and keyed responses look different?">
    No. Success responses are identical, with the same fields and the same schema. Your agent can switch from keyless to keyed without changing how it parses responses.
  </Accordion>

  <Accordion title="Can I use keyless and an API key together?">
    If you send both `X-Tavily-Access-Mode: keyless` and a valid `Authorization: Bearer` header, the API key takes precedence. The request uses your account's limits, not the keyless budget.
  </Accordion>

  <Accordion title="What if I need /crawl, /map, or /research?">
    These endpoints require an API key. [Sign up](https://app.tavily.com) to access them. You get 1,000 free credits monthly.
  </Accordion>
</AccordionGroup>


# Tavily x402
Source: https://docs.tavily.com/documentation/machine-payments/x402

AI agents pay per request for Tavily Advanced Search in USDC on Base — no API key, no account, no human in the loop.

## Overview

Tavily exposes `POST /search` over the [x402](https://x402.org) protocol so an AI agent can call it without an API key. The agent sends a request, gets back HTTP `402` with the price, signs a USDC transfer authorization, and retries. Tavily returns the search results in the same response that settles the payment.

When the agent's USDC settles on Base, Tavily captures the payment and releases the result. Refunds for upstream failures are issued back to the agent's wallet automatically.

<CardGroup>
  <Card title="Tavily x402 endpoint" icon="globe" href="https://x402.tavily.com">
    `https://x402.tavily.com`
  </Card>

  <Card title="Machine-readable pricing" icon="file-lines" href="https://x402.tavily.com/.well-known/pricing">
    `GET /.well-known/pricing` — current pricing as JSON
  </Card>
</CardGroup>

## How a paid request works

<Steps>
  <Step title="Agent → Tavily">
    Agent sends `POST /search` with the search query.
  </Step>

  <Step title="Tavily → Agent">
    Tavily replies `402` with the `PAYMENT-REQUIRED` header.
  </Step>

  <Step title="Agent">
    Decodes the envelope and signs an EIP-3009 USDC transfer authorization.
  </Step>

  <Step title="Agent → Tavily">
    Retries `POST /search` with the signed `PAYMENT-SIGNATURE` header.
  </Step>

  <Step title="Tavily">
    Verifies + settles on Base, then gets search results.
  </Step>

  <Step title="Tavily → Agent">
    Returns `200` with the search results and a `PAYMENT-RESPONSE` header carrying the on-chain receipt.
  </Step>
</Steps>

The `PAYMENT-REQUIRED` response header is base64-encoded JSON. Standard x402 client libraries decode it for you; you only need to handle it manually if you're using your own client. Probe the endpoint to see the raw header:

```bash theme={null}
curl -i -X POST https://x402.tavily.com/search \
  -H 'content-type: application/json' \
  -d '{"query": "Who is Leo Messi?"}'
```

Once decoded (e.g. `base64 -d | jq`), the envelope carries a single `accepts` entry:

```json theme={null}
{
  "x402Version": 2,
  "error": "Payment header is required",
  "resource": {
    "url": "https://x402.tavily.com/search",
    "description": "Tavily Search - advanced mode",
    "mimeType": "application/json"
  },
  "accepts": [
    {
      "scheme": "exact",
      "network": "eip155:8453",
      "amount": "10000",
      "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
      "payTo": "0x…deposit-address",
      "maxTimeoutSeconds": 60,
      "extra": {
        "name": "USD Coin",
        "version": "2",
        "tier": "advanced",
        "terms": "By using the Tavily solution, you agree to be bound by the Terms of Use (https://tavily.com/terms) and Privacy Policy (https://tavily.com/privacy) and accept that Tavily disclaims any liability with regard to the AI agent and cryptocurrency payments."
      }
    }
  ]
}
```

`amount` is in USDC atomic units (6 decimals). `"10000"` = \$0.01.

## Pricing

| Endpoint       | Tier       | Price         |
| -------------- | ---------- | ------------- |
| `POST /search` | `advanced` | \$0.01 / call |

Standard Tavily [search params](/documentation/api-reference/endpoint/search) (`query`, `topic`, `max_results`, `time_range`, `include_domains`, etc.) pass through unchanged; `search_depth` is always `advanced`.

## Network and asset

| Network      | Chain ID      | Asset | Contract                                     |
| ------------ | ------------- | ----- | -------------------------------------------- |
| Base mainnet | `eip155:8453` | USDC  | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` |

The agent must sign for the **exact** atomic amount in `amount`. The on-chain transfer has to match — under-deposits don't settle.

## Client integration

Any x402 v2 client works. The wire protocol is what matters; you don't need a Tavily-specific SDK.

<CodeGroup>
  ```bash awal CLI theme={null}
  npx -y awal x402 pay https://x402.tavily.com/search \
    -X POST \
    -d '{"query":"Who is Leo Messi?"}' \
    --json
  ```

  ```python Python theme={null}
  # pip install 'x402[requests,evm]'
  import os, requests
  from eth_account import Account
  from x402 import x402ClientSync
  from x402.mechanisms.evm.exact import ExactEvmScheme
  from x402.mechanisms.evm.signers import EthAccountSigner
  from x402.http.clients.requests import x402_requests

  account = Account.from_key(os.environ["AGENT_WALLET_KEY"])
  signer = EthAccountSigner(account)

  client = x402ClientSync()
  client.register("eip155:8453", ExactEvmScheme(signer=signer))

  session = x402_requests(client)
  res = session.post(
      "https://x402.tavily.com/search",
      json={"query": "Who is Leo Messi?"},
  )
  print(res.json())
  ```

  ```ts JavaScript / TypeScript theme={null}
  import { wrapFetchWithPayment, x402Client } from "@x402/fetch";
  import { ExactEvmScheme, toClientEvmSigner } from "@x402/evm";
  import { createPublicClient, http } from "viem";
  import { base } from "viem/chains";
  import { privateKeyToAccount } from "viem/accounts";

  const account = privateKeyToAccount(process.env.AGENT_WALLET_KEY as `0x${string}`);
  const publicClient = createPublicClient({ chain: base, transport: http() });
  const signer = toClientEvmSigner(account, publicClient as any);
  const client = new x402Client().register("eip155:8453", new ExactEvmScheme(signer));
  const paidFetch = wrapFetchWithPayment(fetch, client);

  const res = await paidFetch("https://x402.tavily.com/search", {
    method: "POST",
    headers: { "content-type": "application/json" },
    body: JSON.stringify({ query: "Who is Leo Messi?" }),
  });
  console.log(await res.json());
  ```
</CodeGroup>

The client wrapper handles the discovery → sign → retry handshake. From the agent's point of view it's a single `fetch` that costs USDC.

## Response

A successful paid call returns `200` with the standard Tavily search response body plus a `PAYMENT-RESPONSE` header carrying the on-chain settlement tx hash:

```json theme={null}
{
  "query": "Who is Leo Messi?",
  "follow_up_questions": null,
  "answer": null,
  "images": [],
  "results": [
    {
      "title": "Lionel Messi Facts | Britannica",
      "url": "https://www.britannica.com/facts/Lionel-Messi",
      "content": "Lionel Messi, an Argentine footballer, is widely regarded as one of the greatest football players of his generation. Born in 1987, Messi spent the majority of his career playing for Barcelona, where he won numerous domestic league titles and UEFA Champions League titles. Messi is known for his exceptional dribbling skills, vision, and goal",
      "score": 0.81025416,
      "raw_content": null
    }
  ],
  "response_time": 1.5,
  "request_id": "<uuid>"
}
```

`answer`, `follow_up_questions`, `images`, and `auto_parameters` are populated only when the caller opts in (`include_answer`, `include_images`, `auto_parameters` in the request body). The minimal-request shape is what's shown above.

Decode the `PAYMENT-RESPONSE` header to get the receipt:

```json theme={null}
{
  "success": true,
  "payer": "0x…agent-wallet",
  "transaction": "0x…base-mainnet-tx-hash",
  "network": "eip155:8453"
}
```

## Refunds

If the upstream Tavily call fails after the payment has settled, Tavily issues a refund automatically. The refund returns USDC to the wallet that originated the deposit, joined to the original payment via the EIP-3009 `nonce`. No action from the agent is required.

<Warning>
  Refunds route to the wallet that signed the deposit authorization. If the agent paid from an exchange or custodial wallet, the refund lands there. Use a self-custodied wallet for production agents.
</Warning>

## Terms

By using this endpoint you agree to the [Terms of Use](https://tavily.com/terms) and [Privacy Policy](https://tavily.com/privacy). Tavily disclaims any liability with regard to AI agent behavior and cryptocurrency payments. The same language is surfaced inside the `402` envelope under `extra.terms`.


# Tavily MCP Server
Source: https://docs.tavily.com/documentation/mcp

Tavily MCP Server allows you to use the Tavily API in your MCP clients.

<CardGroup>
  <Card title="GitHub" icon="github" href="https://github.com/tavily-ai/tavily-mcp">
    `/tavily-ai/tavily-mcp`

    <img alt="GitHub Repo stars" />
  </Card>

  <Card title="NPM" icon="npm" href="https://www.npmjs.com/package/tavily-mcp">
    `@tavily/mcp`

    <img alt="npm" />
  </Card>
</CardGroup>

<Tip>
  **Compatible with both [Cursor](https://cursor.sh) and [Claude Desktop](https://claude.ai/download)!**

  Tavily MCP is also compatible with any MCP client.
</Tip>

<Info>
  **Check out our
  [tutorial](https://medium.com/@dustin_36183/building-a-knowledge-graph-assistant-combining-tavily-and-neo4j-mcp-servers-with-claude-db92de075df9)
  on combining Tavily MCP with Neo4j MCP server!**
</Info>

<Frame>
  <img alt="Tavily MCP Demo" />
</Frame>

<Tabs>
  <Tab title="Overview">
    The Model Context Protocol (MCP) is an open standard that enables AI systems to interact seamlessly with various data sources and tools, facilitating secure, two-way connections.

    Developed by Anthropic, the Model Context Protocol (MCP) enables AI assistants like Claude to seamlessly integrate with Tavily's advanced search and data extraction capabilities. This integration provides AI models with real-time access to web information, complete with sophisticated filtering options and domain-specific search features.
  </Tab>

  <Tab title="Features">
    The Tavily MCP server provides:

    * Seamless interaction with the tavily-search and tavily-extract tools
    * Real-time web search capabilities through the tavily-search tool
    * Intelligent data extraction from web pages via the tavily-extract tool
  </Tab>
</Tabs>

## Remote MCP Server

The easiest way to take advantage of Tavily MCP is by using the remote URL. This provides a seamless experience without requiring local installation or configuration.

Simply use the remote MCP server URL with your Tavily API key:

```
https://mcp.tavily.com/mcp/?tavilyApiKey=<your-api-key> 
```

Get your Tavily API key from [tavily.com](https://www.tavily.com/).

### Connect to Cursor

[![Install MCP Server](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en-US/install-mcp?name=tavily-remote-mcp\&config=eyJjb21tYW5kIjoibnB4IC15IG1jcC1yZW1vdGUgaHR0cHM6Ly9tY3AudGF2aWx5LmNvbS9tY3AvP3RhdmlseUFwaUtleT08eW91ci1hcGkta2V5PiIsImVudiI6e319)

Click the ⬆️ Add to Cursor ⬆️ button, this will do most of the work for you but you will still need to edit the configuration to add your API-KEY. You can get a Tavily API key [here](https://www.tavily.com/).

once you click the button you should be redirect to Cursor ...

You will then be redirected to your `mcp.json` file where you have to add `your-api-key`.

```json theme={null}
{
  "mcpServers": {
    "tavily-remote-mcp": {
      "command": "npx -y mcp-remote https://mcp.tavily.com/mcp/?tavilyApiKey=<your-api-key>",
      "env": {}
    }
  }
}
```

### Connect to Claude Desktop

Claude desktop now supports adding `integrations` which is currently in beta. An integration in this case is the Tavily Remote MCP, below I will explain how to add the MCP as an `integration` in Claude desktop.

Open claude desktop, click the button with the two sliders and then navigate to add integrations. Name the integration and insert the Tavily remote MCP url with your API key. You can get a Tavily API key [here](https://www.tavily.com/). Click `Add` to confirm.

### OpenAI

Allow models to use remote MCP servers to perform tasks.

* You first need to export your OPENAI\_API\_KEY
* You must also add your Tavily API-key to `<your-api-key>`, you can get a Tavily API key [here](https://www.tavily.com/)

```python theme={null}
from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-4.1",
    tools=[
        {
            "type": "mcp",
            "server_label": "tavily",
            "server_url": "https://mcp.tavily.com/mcp/?tavilyApiKey=<your-api-key>",
            "require_approval": "never",
            ## Optional default parameters:
            "headers": {
                "DEFAULT_PARAMETERS": json.dumps({
                    "include_favicon": True,
                    "include_images": False,
                    "include_raw_content": False,
                }),
            },
        },
    ],
    input="Do you have access to the tavily mcp server?",
)

print(resp.output_text)
```

### Connect to Claude Code

[Claude Code](https://docs.anthropic.com/en/docs/claude-code) natively supports remote MCP servers with OAuth authentication. Add Tavily to your Claude Code configuration by running:

```bash theme={null}
claude mcp add tavily-remote-mcp --transport http https://mcp.tavily.com/mcp/
```

When you start a new conversation, Claude Code will open a browser window for you to complete the OAuth flow and authorize access to your Tavily account. No API key needed in the URL — authentication is handled automatically via OAuth.

You can also manually add the following to your `.claude/settings.json`:

```json theme={null}
{
  "mcpServers": {
    "tavily-remote-mcp": {
      "type": "http",
      "url": "https://mcp.tavily.com/mcp/"
    }
  }
}
```

Alternatively, you can also connect using `mcp-remote`:

```bash theme={null}
claude mcp add tavily-remote-mcp -- npx -y mcp-remote https://mcp.tavily.com/mcp
```

### Clients that don't support remote MCPs

mcp-remote is a lightweight bridge that lets MCP clients that can only talk to local (stdio) servers securely connect to remote MCP servers over HTTP + SSE with OAuth-based auth, so you can host and update your server in the cloud while existing clients keep working. It serves as an experimental stop-gap until popular MCP clients natively support remote, authorized servers.

```json theme={null}
{
    "tavily-remote": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.tavily.com/mcp/?tavilyApiKey=<your-api-key>"
      ]
    }
}
```

### OAuth Authentication

The Tavily Remote MCP server supports secure OAuth authentication, allowing you to connect and authorize seamlessly with compatible clients.

<AccordionGroup>
  <Accordion title="Using MCP Inspector" icon="magnifying-glass">
    Open the MCP Inspector and click "Open Auth Settings". Select the OAuth flow and complete these steps:

    1. Metadata discovery
    2. Client registration
    3. Preparing authorization
    4. Request authorization and obtain the authorization code
    5. Token request
    6. Authentication complete

    Once finished, you will receive an access token that lets you securely make authenticated requests to the Tavily Remote MCP server.
  </Accordion>

  <Accordion title="Using Other MCP Clients" icon="plug">
    You can configure your MCP client to use OAuth without including your Tavily API key in the URL. For example, in Cursor's `mcp.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "tavily-remote-mcp": {
          "command": "npx mcp-remote https://mcp.tavily.com/mcp",
          "env": {}
        }
      }
    }
    ```

    If you need to clear stored OAuth credentials and reauthenticate, run:

    ```bash theme={null}
    rm -rf ~/.mcp-auth
    ```
  </Accordion>
</AccordionGroup>

<Note>
  **API Key Selection for OAuth**

  When using OAuth authentication, you can control which API key is used by naming a key `mcp_auth_default` in your Tavily dashboard:

  * **Personal account**: If you have a key named `mcp_auth_default` in your personal account, it will be used for all OAuth-authenticated requests.
  * **Team account**: If your team has a key named `mcp_auth_default`, it will be used for all OAuth-authenticated requests.
  * **Both set**: If both your personal account and your team have a key named `mcp_auth_default`, the **personal key takes priority**.
  * **Neither set**: If no `mcp_auth_default` key exists, the `default` key in your personal account will be used. If no `default` key is set, the first available key will be used.

  OAuth authentication is optional—you can still use API key authentication at any time by including your Tavily API key in the URL query parameter (`?tavilyApiKey=...`) or by setting it in the Authorization header.
</Note>

Alternatively, you can also run the MCP server locally.

### Default Parameters

When using the remote MCP, you can specify default parameters for all requests by including a `DEFAULT_PARAMETERS` header containing a JSON object with your desired defaults. Example:

```
{"include_images":true, "search_depth": "advanced", "max_results": 10}
```

### Session & User Attribution

The remote MCP server automatically attaches identifiers to every Tavily API call so requests can be attributed back to a session. It generates `X-Session-Id` on its own, while `X-Human-Id` is forwarded only when supplied by the client.

* **`X-Session-Id`** — generated per MCP session (the `mcp-session-id` returned during the MCP `initialize` handshake). All tool calls within the same MCP session share the same value.
* **`X-Human-Id`** — if your client provides an `X-Human-Id` header (or `humanId` query parameter on the MCP URL), it is forwarded through to the Tavily API, helping Tavily better understand multi-step interactions and improve response quality. For security, Tavily hashes human IDs before processing or storing them.

See [Session Tracking](/documentation/api-reference/introduction#session--user-tracking) for the underlying API contract.

## Local Installation

### Prerequisites

<AccordionGroup>
  <Accordion title="Required Tools" icon="wrench">
    * [Tavily API key](https://app.tavily.com/home)
      * If you don't have a Tavily API key, you can sign up for a free account [here](https://app.tavily.com/home)
    * [Claude Desktop](https://claude.ai/download) or [Cursor](https://cursor.sh)
    * [Node.js](https://nodejs.org/) (v20 or higher)
      * You can verify your Node.js installation by running:
        ```bash theme={null}
        node --version
        ```
  </Accordion>

  <Accordion title="Git Installation (Optional)" icon="code-branch">
    Only needed if using Git installation method:

    * On macOS: `brew install git`
    * On Linux:
      * Debian/Ubuntu: `sudo apt install git`
      * RedHat/CentOS: `sudo yum install git`
    * On Windows: Download [Git for Windows](https://git-scm.com/download/win)
  </Accordion>
</AccordionGroup>

<CodeGroup>
  ```bash NPX theme={null}
  npx -y tavily-mcp@0.1.3
  ```

  ```bash Git theme={null}
  git clone https://github.com/tavily-ai/tavily-mcp.git
  cd tavily-mcp
  npm install
  npm run build
  ```
</CodeGroup>

<Note>
  Although you can launch a server on its own, it's not particularly helpful in
  isolation. Instead, you should integrate it into an MCP client.
</Note>

### Configuring MCP Clients

<Tabs>
  <Tab title="Cursor">
    > **Note**: Requires Cursor version 0.45.6 or higher

    To set up the Tavily MCP server in Cursor:

    1. Open Cursor Settings
    2. Navigate to Features > MCP Servers
    3. Click on the "+ Add New MCP Server" button
    4. Fill out the following information:
       * **Name**: Enter a nickname for the server (e.g., "tavily-mcp")
       * **Type**: Select "command" as the type
       * **Command**: Enter the command to run the server:
         ```bash theme={null}
         env TAVILY_API_KEY=tvly-YOUR_API_KEY npx -y tavily-mcp@0.1.3
         ```
         <Warning>Replace `tvly-YOUR_API_KEY` with your Tavily API key from [app.tavily.com/home](https://app.tavily.com/home)</Warning>

    <Frame>
      <img alt="Cursor Interface Example" />
    </Frame>
  </Tab>

  <Tab title="Claude Desktop">
    <CodeGroup>
      ```bash macOS theme={null}
      # Create the config file if it doesn't exist
      touch "$HOME/Library/Application Support/Claude/claude_desktop_config.json"

      # Opens the config file in TextEdit
      open -e "$HOME/Library/Application Support/Claude/claude_desktop_config.json"

      # Alternative method using Visual Studio Code
      code "$HOME/Library/Application Support/Claude/claude_desktop_config.json"
      ```

      ```bash Windows theme={null}
      code %APPDATA%\Claude\claude_desktop_config.json
      ```
    </CodeGroup>

    Add this configuration (replace `tvly-YOUR_API_KEY-here` with your [Tavily API key](https://tavily.com/api-keys)):

    ```json Configuration theme={null}
    {
      "mcpServers": {
        "tavily-mcp": {
          "command": "npx",
          "args": ["-y", "tavily-mcp@0.1.2"],
          "env": {
            "TAVILY_API_KEY": "tvly-YOUR_API_KEY-here"
          }
        }
      }
    }
    ```
  </Tab>
</Tabs>

### Default Parameters

For local MCP setups, you can set default parameter values using the `DEFAULT_PARAMETERS` environment variable. This allows you to configure default search behavior without specifying these parameters in every request.

```json theme={null}
{
  "mcpServers": {
    "tavily-mcp": {
      "command": "npx",
      "args": ["-y", "tavily-mcp@latest"],
      "env": {
        "TAVILY_API_KEY": "your-api-key-here",
        "DEFAULT_PARAMETERS": "{\"include_images\": true, \"max_results\": 15, \"search_depth\": \"advanced\"}"
      }
    }
  }
}
```

### Session & User Attribution

The local MCP server automatically attaches identifiers to every Tavily API call so requests can be attributed back to a session:

* **`X-Session-Id`** — auto-generated once per MCP process and reused for every tool call.
* **`X-Human-Id`** — if you set the `HUMAN_ID` environment variable, that value is forwarded through to the Tavily API on every request, helping Tavily better understand multi-step interactions and improve response quality. For security, Tavily hashes human IDs before processing or storing them.

See [Session Tracking](/documentation/api-reference/introduction#session--user-tracking) for the underlying API contract.

## Usage Examples

<AccordionGroup>
  <Accordion title="Tavily Search Examples" icon="magnifying-glass">
    1. **General Web Search**:

    ```
    Can you search for recent developments in quantum computing?
    ```

    2. **News Search**:

    ```
    Search for news articles about AI startups from the last 7 days.
    ```

    3. **Domain-Specific Search**:

    ```
    Search for climate change research on nature.com and sciencedirect.com
    ```
  </Accordion>

  <Accordion title="Tavily Extract Examples" icon="file-export">
    **Extract Article Content**: `Extract the main content from this article:
          https://example.com/article`
  </Accordion>

  <Accordion title="Combined Usage" icon="wand-magic-sparkles">
    ```
    Search for news articles about AI startups from the last 7 days and extract the main content from each article to generate a detailed report.
    ```
  </Accordion>
</AccordionGroup>

## Troubleshooting

<Accordion title="Server Not Found" icon="server">
  If you encounter server connection issues, run these commands to verify your environment:

  ```bash theme={null}
  npm --version
  node --version
  ```

  Make sure to also check your configuration syntax for any errors.
</Accordion>

<Accordion title="NPX Issues" icon="terminal">
  If experiencing problems with npx, locate your executable:

  ```bash theme={null}
  which npx
  ```

  <Tip>
    Once you have the path, update your configuration to use the full path to the npx executable.
  </Tip>
</Accordion>

<Accordion title="API Key Issues" icon="key">
  When troubleshooting API key problems, verify that your key is:

  * Properly formatted with the `tvly-` prefix
  * Valid and active in your Tavily dashboard
  * Correctly configured in your environment variables

  <Tip>
    You can test your API key validity by making a simple test request through the [Tavily Playground](https://app.tavily.com/playground)
  </Tip>
</Accordion>

## Acknowledgments

<CardGroup>
  <Card title="Model Context Protocol" icon="book" href="https://modelcontextprotocol.io">
    For the MCP specification
  </Card>

  <Card title="Anthropic" icon="robot" href="https://www.anthropic.com/claude">
    For Claude Desktop
  </Card>
</CardGroup>


# Amazon Bedrock AgentCore
Source: https://docs.tavily.com/documentation/partnerships/amazon

Integrate Tavily MCP Server with Amazon Bedrock AgentCore for scalable AI agent deployment on AWS.

## Overview

The [Tavily MCP Server](https://aws.amazon.com/marketplace/pp/prodview-twjga5bwmoszq) is available on the AWS Marketplace and can be deployed as a managed MCP server on [Amazon Bedrock AgentCore](https://aws.amazon.com/bedrock/agentcore/), enabling developers to securely run and scale AI agents with access to Tavily's real-time web search, content extraction, crawling, and site mapping capabilities.

## Prerequisites

* [AWS account](https://aws.amazon.com/)
* [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) installed and [configured](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-quickstart.html)
* [Tavily API Key](https://app.tavily.com/home) for authenticating the Tavily MCP Server
* An IAM role with a trust policy allowing `bedrock-agentcore.amazonaws.com` to assume the role

## Setup

<Steps>
  <Step title="Subscribe on the AWS Marketplace">
    Visit the [Tavily MCP Server listing](https://aws.amazon.com/marketplace/pp/prodview-twjga5bwmoszq)
    on the AWS Marketplace. Click **View purchase options**, scroll down, and
    select **Subscribe**. Once your request has been processed, click **Launch
    your software** in the pop-up that appears.

    <Frame>
      <img alt="Tavily MCP Server listing on the AWS Marketplace" />
    </Frame>
  </Step>

  <Step title="Select Amazon Bedrock AgentCore">
    On the launch page, select **Amazon Bedrock AgentCore console** as the
    Launch Method.

    <Frame>
      <img alt="Select Amazon Bedrock AgentCore as the deployment target" />
    </Frame>
  </Step>

  <Step title="Create an IAM Role">
    Create an IAM role that allows Bedrock AgentCore to assume it. When
    creating the role, select **Custom trust policy** and replace the default
    JSON with the following:

    ```json theme={null}
    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Sid": "Statement1",
          "Effect": "Allow",
          "Principal": {
            "Service": "bedrock-agentcore.amazonaws.com"
          },
          "Action": "sts:AssumeRole"
        }
      ]
    }
    ```

    Make sure to run `aws configure` in your terminal and add the access keys
    associated with the account where you created the IAM role.
  </Step>

  <Step title="Deploy the Agent Runtime">
    From AWS CloudShell or a Linux/macOS terminal, run the following command.
    Replace the placeholders with your own values:

    * `<AGENT_NAME>`: A name of your choice
    * `<AGENT_DESCRIPTION>`: A description of your choice
    * `<AGENT_ROLE_ARN>`: The ARN of the IAM role created in the previous step
    * `<your-tavily-api-key>`: Your [Tavily API key](https://app.tavily.com/home)

    ```bash theme={null}
    aws bedrock-agentcore-control create-agent-runtime \
      --region us-east-1 \
      --agent-runtime-name "<AGENT_NAME>" \
      --description "<AGENT_DESCRIPTION>" \
      --agent-runtime-artifact '{
        "containerConfiguration": {
          "containerUri": "709825985650.dkr.ecr.us-east-1.amazonaws.com/tavily/tavily-mcp:v6"
        }
      }' \
      --role-arn "<AGENT_ROLE_ARN>" \
      --network-configuration '{
        "networkMode": "PUBLIC"
      }' \
      --protocol-configuration '{
        "serverProtocol": "MCP"
      }' \
      --environment-variables '{
        "TAVILY_API_KEY": "<your-tavily-api-key>"
      }'
    ```

    Once the command completes, you will receive an output containing the
    `agentRuntimeArn`. Save this value for the next step.

    ```json theme={null}
    {
      "agentRuntimeArn": "...",
      "workloadIdentityDetails": {
        "workloadIdentityArn": "..."
      },
      "agentRuntimeId": "...",
      "agentRuntimeVersion": "...",
      "createdAt": "...",
      "status": "..."
    }
    ```
  </Step>

  <Step title="Invoke the Agent Runtime">
    Use the `agentRuntimeArn` from the previous step to invoke Tavily MCP
    tools. For example, to list all available tools:

    ```bash theme={null}
    export PAYLOAD='{ "jsonrpc": "2.0", "id": 1, "method": "tools/list",
      "params": { "_meta": { "progressToken": 1 }}}'

    aws bedrock-agentcore invoke-agent-runtime \
      --agent-runtime-arn "<AGENT_RUNTIME_ARN>" \
      --content-type "application/json" \
      --accept "application/json, text/event-stream" \
      --payload "$(echo -n "$PAYLOAD" | base64)" output.json
    ```

    You can also invoke specific tools by changing the payload. Here are some
    examples:

    **[Search](/documentation/api-reference/endpoint/search) the web:**

    ```json theme={null}
    {
      "jsonrpc": "2.0",
      "id": "1",
      "method": "tools/call",
      "params": {
        "name": "tavily_search",
        "arguments": { "query": "latest AI news", "max_results": 10 }
      }
    }
    ```

    **[Extract](/documentation/api-reference/endpoint/extract) content from a URL:**

    ```json theme={null}
    {
      "jsonrpc": "2.0",
      "id": "1",
      "method": "tools/call",
      "params": {
        "name": "tavily_extract",
        "arguments": { "urls": ["www.tavily.com"] }
      }
    }
    ```

    **[Crawl](/documentation/api-reference/endpoint/crawl) a website:**

    ```json theme={null}
    {
      "jsonrpc": "2.0",
      "id": "1",
      "method": "tools/call",
      "params": {
        "name": "tavily_crawl",
        "arguments": { "url": "www.tavily.com" }
      }
    }
    ```

    **[Map](/documentation/api-reference/endpoint/map) a website's structure:**

    ```json theme={null}
    {
      "jsonrpc": "2.0",
      "id": "1",
      "method": "tools/call",
      "params": {
        "name": "tavily_map",
        "arguments": { "url": "www.tavily.com" }
      }
    }
    ```
  </Step>
</Steps>

## Resources

* [Amazon Bedrock AgentCore Documentation](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/agentcore-get-started-toolkit.html)
* [AWS CLI Installation Guide](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
* [Tavily MCP Documentation](/documentation/mcp)
* [Tavily API Reference](/documentation/api-reference/endpoint/search)


# Microsoft Azure
Source: https://docs.tavily.com/documentation/partnerships/azure

Integrate Tavily Remote MCP with Microsoft Azure AI Foundry and Azure MCP Center for seamless AI agent development.

## Overview

Tavily Remote MCP is now available on Microsoft Azure, providing seamless integration for developers building AI agents and workflows. By being listed on Azure MCP Center and included in Azure AI Foundry's Tools Catalog, Tavily enables users to easily discover and connect to its powerful capabilities for grounding AI agents with real-time web search and RAG pipelines.

* **[Azure AI Foundry](https://ai.azure.com)** — Tavily is featured in the Tools Catalog of Azure AI Foundry, making it easy for users to add Tavily to their AI agent workflows and leverage its capabilities for real-time information retrieval and grounding.

* **[Azure MCP Center](https://mcp.azure.com/detail/tavily-mcp)** — Tavily Remote MCP is listed on Azure's MCP Center (part of Azure API Center), enabling developers to discover and connect to Tavily directly.

## Prerequisites

* [Microsoft Azure account](https://azure.microsoft.com/) with active subscription for signing in to [Azure AI Foundry](https://ai.azure.com)
* [Tavily API Key](https://app.tavily.com/home) for connecting the Tavily Remote MCP to Azure AI Foundry

## Setup

### Azure AI Foundry

<Steps>
  <Step title="Visit Azure AI Foundry">
    Go to [Azure AI Foundry](https://ai.azure.com/) and sign in with your
    Microsoft Azure account.
  </Step>

  <Step title="Toggle on the New Foundry">
    On the top bar, toggle on the **New Foundry** to switch from Microsoft
    Foundry (classic) to Microsoft Foundry (New).

    <Frame>
      <img alt="Toggle on New Foundry experience in Azure AI Foundry" />
    </Frame>
  </Step>

  <Step title="Select or create a new project">
    A pop-up will appear to select an existing project or create a new one.
    Select the project you want to work on or create a new project to get
    started.

    <Frame>
      <img alt="Select or create a new project in Azure AI Foundry" />
    </Frame>
  </Step>

  <Step title="Enter Project Details">
    Fill in the required project details such as Foundry resource, subscription,
    region, and resource group to set up your project environment to create a
    new project in Microsoft Foundry(new).

    <Frame>
      <img alt="Enter project details in Azure AI Foundry" />
    </Frame>
  </Step>

  <Step title="Create an agent">
    Once your project is set up, click on the **Start Building** button to
    create a new agent within your project.

    <Frame>
      <img alt="Create a new agent in Azure AI Foundry" />
    </Frame>
  </Step>

  <Step title="Add Tavily MCP to your agent workflow">
    In the playground interface, navigate to the **Tools** section and search
    for **Tavily MCP** in the catalog. Enter your Tavily API Key to authenticate
    and connect your agent to the Tavily Remote MCP. Once connected, Tavily MCP
    will be available as a tool in your agent's workflow for real-time web
    search and RAG capabilities.

    <Frame>
      <img alt="Add Tavily MCP to agent workflow in Azure AI Foundry" />
    </Frame>
  </Step>

  <Step title="Start using Tavily MCP in your agent workflow">
    With Tavily MCP added to your agent's tools, you can now use it within your
    agent's workflow to enhance its capabilities with real-time information
    retrieval and grounding for more effective AI agent performance.

    <Frame>
      <img alt="Use Tavily MCP in agent workflow in Azure AI Foundry" />
    </Frame>
  </Step>
</Steps>

### Azure MCP Center

<Steps>
  <Step title="Visit Azure MCP Center">
    Go to the [Azure MCP Center](https://mcp.azure.com/) and search for **Tavily
    MCP** to find the listing.
  </Step>

  <Step title="Install in VS Code">
    Click the **Install** button on the Azure MCP Center listing for Tavily MCP
    to add it to your VS Code.

    <Frame>
      <img alt="Search for Tavily in Azure MCP Center" />
    </Frame>
  </Step>

  <Step title="Authenticate with Tavily Account">
    VS Code will prompt you to authenticate with your Tavily account to connect
    to the Remote MCP. Follow the authentication flow to grant access.

    <Frame>
      <img alt="Authentication prompt for Tavily MCP in VS Code" />
    </Frame>
  </Step>

  <Step title="Start using Tavily MCP with Copilot">
    Use Tavily MCP within VS Code's Copilot to enhance your AI agent development
    with real-time web search and RAG capabilities.
  </Step>
</Steps>

## Resources

* [Build a workflow in Microsoft Foundry](https://learn.microsoft.com/en-us/azure/ai-foundry/agents/concepts/workflow)
* [Use MCP servers in VS Code](https://code.visualstudio.com/docs/copilot/customization/mcp-servers)
* [Tavily MCP Documentation](/documentation/mcp)


# Databricks
Source: https://docs.tavily.com/documentation/partnerships/databricks

Integrate Tavily MCP Server with Databricks for real-time web search and RAG capabilities.

## Overview

Tavily MCP Server is available on [Databricks Marketplace](https://marketplace.databricks.com/details/3709f418-1ed3-42a8-a753-38d06ce281c7/Tavily_Tavily-MCP-Server), enabling one-click installation that creates a secure Unity Catalog connection for authenticated access. Once installed, Tavily MCP can be used programmatically in your agent code (LangGraph, OpenAI, etc.) through Databricks-managed proxy endpoints, grounding your AI agents with real-time web search, extraction, crawling, and mapping.

## Prerequisites

* [Databricks workspace](https://www.databricks.com/) with the **Managed MCP Servers** preview enabled. See [Manage Databricks previews](https://docs.databricks.com/aws/en/admin/workspace-settings/manage-previews).
* `CREATE CONNECTION` privilege on the Unity Catalog metastore
* [Tavily API Key](https://app.tavily.com/home) for authenticating the Tavily MCP connection (via bearer token)

## Setup

### Install from Databricks Marketplace

<Steps>
  <Step title="Navigate to Marketplace and find Tavily MCP Server">
    In your Databricks workspace, go to **Marketplace** and search for **Tavily MCP Server**.

    <Frame>
      <img alt="Search for Tavily MCP Server in Databricks Marketplace" />
    </Frame>
  </Step>

  <Step title="Install and configure the connection">
    Click **Install** to install the Tavily MCP Server. In the installation dialog, configure the connection settings:

    * **Connection name**: Enter a name for the Unity Catalog connection (for example, `tavily_mcp_connection`).
    * **Host**: Pre-populated for Tavily.
    * **Base path**: Pre-populated for Tavily.
    * **Bearer token**: Enter your Tavily API Key as the bearer token.

    <Frame>
      <img alt="Configure the connection for Tavily MCP Server" />
    </Frame>
  </Step>

  <Step title="Verify Unity Catalog Connection">
    Navigate to **Unity Catalog** > **Connect** > **Connections** and verify that the connection has been created successfully.

    <Frame>
      <img alt="Verify the connection from Unity Catalog" />
    </Frame>
  </Step>
</Steps>

### Share the MCP server connection

<Steps>
  <Step title="Open the Unity Catalog connection">
    Navigate to **Unity Catalog** > **Connect** > **Connections** and click on the connection you created earlier (for example, `tavily_mcp_connection`).

    <Frame>
      <img alt="Open the Unity Catalog Connections" />
    </Frame>
  </Step>

  <Step title="Grant access to the connection">
    Grant `USE CONNECTION` privileges to identity principals that need to use the Tavily MCP server connection. In your workspace, go to **Permissions** tab and grant **`USE CONNECTION`** to the identity principals that need to use the Tavily MCP server connection.

    <Frame>
      <img alt="Grant USE CONNECTION privileges to identity principals" />
    </Frame>
  </Step>
</Steps>

### Test Tavily MCP Server within Databricks

You can test the Tavily MCP server directly within Databricks without writing any code.

**Using AI Playground:**

<Steps>
  <Step title="Open AI Playground">
    Go to **AI Playground** in your Databricks workspace and choose a model with
    the **Tools enabled** label.

    <Frame>
      <img alt="Select a model in AI Playground" />
    </Frame>
  </Step>

  <Step title="Add Tavily MCP Server as a tool">
    Click **Tools** tab and select **+ Add tool** and select **MCP Servers** from the available tool options. In the MCP Servers section, select **External MCP servers** to
    browse available connections, and choose the Unity Catalog connection you
    installed earlier (for example, `tavily_mcp_connection`).

    <Frame>
      <img alt="Add Tavily MCP Server as a tool" />
    </Frame>
  </Step>

  <Step title="Chat and test Tavily MCP Server">
    Chat with the LLM to test how it interacts with Tavily MCP tools.

    <Frame>
      <img alt="Test Tavily MCP Server results" />
    </Frame>
  </Step>
</Steps>

### Add Tavily MCP Server to Databricks Assistant

<Steps>
  <Step title="Open Databricks Assistant">
    Go to **Databricks Assistant** in your Databricks workspace and click on the **Settings** icon.
  </Step>

  <Step title="Add MCP Server from Settings">
    In **MCP Servers** section, select **+ Add MCP Server**. Go to **External MCP servers** dropdown and choose the Unity Catalog connection you installed earlier (for example, `tavily_mcp_connection`).

    <Frame>
      <img alt="Add MCP Server from Settings" />
    </Frame>
  </Step>
</Steps>

### Use Tavily MCP in Your Agent Code

After installation, use Tavily MCP programmatically in your agent code by connecting to the proxy URL. The Databricks proxy makes external servers behave like managed MCP servers, handling authentication and token management.

<Steps>
  <Step title="Configure the proxy endpoint">
    Add the Tavily MCP proxy endpoint to your `MANAGED_MCP_SERVER_URLS` list. External MCP servers are proxied as managed servers, allowing you to use the same API for both:

    ```python theme={null}
    from databricks.sdk import WorkspaceClient
    from databricks_mcp import DatabricksMCPClient

    # Initialize workspace client
    workspace_client = WorkspaceClient()
    host = workspace_client.config.host

    # External MCP servers are proxied as managed servers, allowing you
    # to use the same API for both managed and external servers
    MANAGED_MCP_SERVER_URLS = [
        f"{host}/api/2.0/mcp/functions/system/ai",  # Default managed MCP
        f"{host}/api/2.0/mcp/external/tavily_mcp_connection"  # Tavily MCP proxy
    ]
    ```
  </Step>

  <Step title="Use with agents">
    Pass the proxy URL to the `managed_server_urls` parameter to create tools from both managed and external (proxied) servers:

    ```python theme={null}
    # Use with agents — external servers work just like managed ones
    import asyncio
    from your_agent_code import create_mcp_tools  # Your agent's tool creation function

    # Create tools from both managed and external (proxied) servers
    mcp_tools = asyncio.run(
        create_mcp_tools(
            ws=workspace_client,
            managed_server_urls=MANAGED_MCP_SERVER_URLS
        )
    )
    ```
  </Step>

  <Step title="Call tools directly (optional)">
    You can also call Tavily tools directly using the Databricks MCP Client:

    ```python theme={null}
    # Direct tool call using DatabricksMCPClient
    mcp_client = DatabricksMCPClient(
        server_url=f"{host}/api/2.0/mcp/external/tavily_mcp_connection",
        workspace_client=workspace_client
    )

    # List available tools
    tools = mcp_client.list_tools()
    print(f"Available tools: {[tool.name for tool in tools]}")

    # Call a tool
    response = mcp_client.call_tool(
        "tavily_search",
        {"query": "latest AI research breakthroughs"}
    )
    print(response.content[0].text)
    ```
  </Step>
</Steps>

## Resources

* [Tavily MCP Server on Databricks Marketplace](https://marketplace.databricks.com/details/3709f418-1ed3-42a8-a753-38d06ce281c7/Tavily_Tavily-MCP-Server)
* [Tavily MCP Documentation](/documentation/mcp)


# IBM watsonx Orchestrate
Source: https://docs.tavily.com/documentation/partnerships/ibm

Integrate Tavily's AI-powered research capabilities with IBM watsonx Orchestrate

## Overview

Tavily offers two services on IBM watsonx Orchestrate:

* **Tavily Research Agent** — An AI-powered research agent that conducts comprehensive web research using coordinated parallel sub-agents to deliver detailed, citation-backed reports on complex topics.
* **Tavily Search API** — Real-time web search optimized for AI agents and LLMs.

Both services are available through the IBM Cloud catalog and can be procured using IBM credits.

## Setup Guide

### Step 1: Create a Tavily Instance on IBM Cloud

1. Navigate to [IBM Cloud](https://cloud.ibm.com/)
2. In the search bar, type "Tavily" to find the available services

<Frame>
  <img alt="Search for Tavily in IBM Cloud" />
</Frame>

3. Select either **Tavily Search API** or **Tavily Research Agent** depending on your needs
4. Click **Create** to provision a new instance

<Frame>
  <img alt="Create Tavily instance" />
</Frame>

### Step 2: Copy Your Bearer Token

Once your instance is created, copy the bearer token from the credentials section. You'll need this to connect the agent in watsonx Orchestrate.

<Frame>
  <img alt="Copy bearer token" />
</Frame>

### Step 3: Add Tavily to watsonx Orchestrate

1. Navigate to [watsonx Orchestrate](https://dl.watson-orchestrate.ibm.com/chat)
2. Create a new agent

<Frame>
  <img alt="Create agent in watsonx Orchestrate" />
</Frame>

3. Name your agent

<Frame>
  <img alt="Name your agent" />
</Frame>

4. Add a collaborator agent

<Frame>
  <img alt="Add collaborator agent" />
</Frame>

5. Select **Tavily Research Agent** from the partner agents list

<Frame>
  <img alt="Select Tavily agent" />
</Frame>

6. Review the agent details and click **Add as collaborator**

<Frame>
  <img alt="Add Tavily as collaborator" />
</Frame>

7. Enter your bearer token (from Step 2) in the **Bearer token** field and click **Register and add**

<Frame>
  <img alt="Register agent with bearer token" />
</Frame>

8. The Tavily Research Agent will now appear in your agent's **Toolset** under the Agents section

<Frame>
  <img alt="Tavily agent loaded in toolset" />
</Frame>

### Step 4: Try It Out

Ask a question in the chat that requires real-time web research, and watsonx Orchestrate will automatically hand off to the Tavily Research Agent.

<Frame>
  <img alt="Tavily Research Agent handoff example" />
</Frame>

Your Tavily Research Agent is now ready to use within watsonx Orchestrate.

## Resources

* [IBM watsonx Orchestrate Documentation](https://www.ibm.com/docs/en/watsonx/watson-orchestrate/base?topic=agents-adding-orchestration#adding-a-collaborator-agent)
* [Partner Agents Catalog](https://www.ibm.com/docs/en/watsonx/watson-orchestrate/base?topic=catalog-partner-agents)


# Snowflake
Source: https://docs.tavily.com/documentation/partnerships/snowflake

Tavily is now available as a native app on the [Snowflake Marketplace](https://app.snowflake.com/marketplace/listing/GZTSZ2XM0ON/tavily-tavily-search-api?search=tavily).

## Introduction

The Tavily Snowflake Native App brings powerful web search capabilities directly into your Snowflake environment, allowing you to download and install it natively within your Snowflake account in an easy and secure way.

## Tutorial

The following video walks you through the above-mentioned steps for installing, configuring, and using the Tavily Snowflake Native App.

<Frame>
  <iframe title="YouTube video player" />
</Frame>

## Installation and Setup

1. After logging into your Snowflake account, click on ***Marketplace*** from the sidebar.

2. In the search bar, search for ***Tavily*** and find the ***Tavily Search API*** app.

3. Click on ***GET*** in the right top side to download the app into your Snowflake account.

4. Read through the permissions and click on ***Agree and Continue*** and click on ***GET***.

5. After the app finished downloading, hover over ***Catalog*** in the left sidebar and click on ***Apps***.

6. Locate the Tavily app named ***Tavily Search API*** in the installed apps section.

7. Now you have to configure the application.

8. Visit [https://tavily.com](https://tavily.com) to get your API key if you don't already have one.

9. After you have your API key, click on the ***Configure*** button and pass the API key in the secret value box to configure the API key for your native app.

10. Now, in the ***Review integration requests*** section, click on ***Review*** and toggle the button to the right to enable your app ***Access the Tavily external API for web search***.

11. Click on ***Save***. Now you have successfully configured your application for use in the Snowflake environment.

12. Click on ***Next*** to visit the app page.

## Use cases

### Using TAVILY\_WEB\_SEARCH in Snowsight

1. After installation in the app page, you can click on ***Open Worksheet*** to pop up a Snowflake worksheet with a pre-loaded SQL query to use Tavily web search.

2. Make sure to select the appropriate database for your worksheet. In the top right, ensure the database is `TAVILY_SEARCH_API` and the schema is `TAVILY_SCHEMA`.

3. Now you can click the ***Run*** button on the top left of your worksheet to run the query.

SQL Procedure: `TAVILY_SCHEMA.TAVILY_WEB_SEARCH`

**Parameters:**

* `QUERY` (VARCHAR): The search query in natural language

* `SEARCH_DEPTH` (VARCHAR, optional): `'basic'` (default) or `'advanced'`

* `MAX_RESULTS` (INTEGER, optional): Maximum number of results (default: 5)

**Example:**

```sql theme={null}
CALL TAVILY_SCHEMA.TAVILY_WEB_SEARCH('latest Quantum computing trends', 'advanced', 10);
```

**Data Enrichment**:
With this setup, you can enhance your Snowflake database with up-to-date information from the web, enabling you to fill your data warehouse with real-world data and keep your analytics current with the latest trends and events.

`For example`: During data analysis in your Snowflake environment, you may discover records with missing, null, or outdated values, such as incomplete company details, stale product information, or missing metadata. Instead of filling these gaps manually, you can leverage the `TAVILY_WEB_SEARCH` stored procedure to automatically query reliable sources on the web. This allows you to fetch the most current information available and enrich your dataset directly within Snowflake, improving data completeness, accuracy, and overall analytical value.

### Using TAVILY\_WEB\_SEARCH in Snowflake Intelligence

1. **Set up Snowflake Intelligence**: Follow the [Snowflake documentation](https://docs.snowflake.com/en/user-guide/snowflake-cortex/snowflake-intelligence) to set up Snowflake Intelligence. Make sure you have the snowflake\_intelligence database, required schema and GRANTs before proceeding to the next steps.

2. **Create an Agent**: In the Snowsight UI sidebar, navigate to the ***Agents*** admin page under ***AI & ML***, click on ***create agent*** and provide agent object name, display name and create the agent.

3. **Add the TAVILY\_WEB\_SEARCH Custom Tool**: Within the current agent's menu bar, navigate to the ***Tools*** section and click on ***+Add*** in Custom tools.

   * Select the Resource type as ***Procedure***

   * Select the database and schema: `TAVILY_SEARCH_API.TAVILY_SCHEMA`

   * Select the custom tool identifier: `TAVILY_SEARCH_API.TAVILY_SCHEMA.TAVILY_WEB_SEARCH`

   * Give your tool a descriptive name

   * Configure the following parameters with their descriptions:

     * `query`: "Search query"

     * `search_depth`: "The depth of the search. It can be 'basic' or 'advanced'"

     * `max_results`: "The maximum number of search results to return. Minimum is 1 and Maximum is 20"

   * Click on ***Add*** to attach the tool to your agent

   * Make sure to click on ***Save*** in the top right corner to update the agent

4. **Use the Agent**: In the Snowsight UI sidebar, navigate to the ***Snowflake Intelligence*** landing page under ***AI & ML***, select the agent you created, and use the tool.

`Real-time AI agents`:
With Snowflake Intelligence, you can ask complex questions about your data in natural language and receive insights from your own personalized enterprise intelligence agent. To ensure those insights are both accurate and current, it’s important to ground the agent in real-time information. By integrating the `TAVILY_WEB_SEARCH` tool, you allow the agent to automatically pull fresh, relevant data from the web, thus resulting in more trustworthy analysis and more informed decision-making.


# Quickstart
Source: https://docs.tavily.com/documentation/quickstart

Start searching with Tavily in under 5 minutes.

## Get your free Tavily API key

Head to the [Tavily Platform](https://app.tavily.com) and sign in (or create an account). Then, copy one of your API keys from your dashboard.

<Card icon="key" href="https://app.tavily.com" title="Get your free API key">
  You get 1,000 free API Credits every month. **No credit card required.**
</Card>

## Install Tavily

Install the Tavily SDK in your language of choice.

<CodeGroup>
  ```bash Python theme={null}
  pip install tavily-python
  ```

  ```bash JavaScript theme={null}
  npm i @tavily/core
  ```
</CodeGroup>

## Start searching with Tavily

Run your first Tavily Search in 4 lines of code. Simply replace the API key in this snippet with your own.

<CodeGroup>
  ```python Python theme={null}
  from tavily import TavilyClient

  tavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")
  response = tavily_client.search("Who is Leo Messi?")

  print(response)
  ```

  ```js JavaScript theme={null}
  const { tavily } = require("@tavily/core");

  const tvly = tavily({ apiKey: "tvly-YOUR_API_KEY" });
  const response = await tvly.search("Who is Leo Messi?");

  console.log(response);
  ```

  ```bash cURL theme={null}
  curl -X POST https://api.tavily.com/search \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer tvly-YOUR_API_KEY" \
    -d '{"query": "Who is Leo Messi?"}'
  ```
</CodeGroup>

## Next steps

That's all it takes to start using Tavily's basic features!

If you want to learn how to implement more complex workflows in Python, check out our intermediate-level [Getting Started notebook](https://colab.research.google.com/drive/1dWGtS3u4ocCLebuaa8Ivz7BkZ_40IgH1).

Or, dive deep into our API and read about the different parameters on our [API Reference](/documentation/api-reference/introduction) page, and learn how to integrate natively with one of our [SDKs](/sdk).


# Rate Limits
Source: https://docs.tavily.com/documentation/rate-limits

Learn about Tavily's API rate limits for both  development and production environments.

We offer two types of rate limits based on the environment associated with your API key.

<Card icon="key" href="https://app.tavily.com" title="Get your API key">
  Create your Development or Production API keys.
</Card>

| Environment   | Requests per minute (RPM) |
| ------------- | ------------------------- |
| `Development` | 100                       |
| `Production`  | 1,000                     |

## Crawl Endpoint Rate Limits

The crawl endpoint has a separate rate limit that applies to both development and production keys:

| Environment   | Requests per minute (RPM) |
| ------------- | ------------------------- |
| `Development` | 100                       |
| `Production`  | 100                       |

## Research Endpoint Rate Limits

The research endpoint has a separate rate limit that applies to both development and production keys for creating research tasks. Note that polling requests to retrieve the status of ongoing research tasks follow the default rate limits as decribed above.

| Environment   | Requests per minute (RPM) |
| ------------- | ------------------------- |
| `Development` | 20                        |
| `Production`  | 20                        |

## Usage Endpoint Rate Limits

The usage endpoint has a separate rate limit that applies to both development and production keys:

| Environment   | Requests per 10 minutes |
| ------------- | ----------------------- |
| `Development` | 10                      |
| `Production`  | 10                      |

## Handling Rate Limit Responses

When you exceed the rate limit, the API returns a `429 Too Many Requests` response with a `retry-after` header indicating the number of seconds to wait before making another request.

```
HTTP/2 429 Too Many Requests
retry-after: 60
{
  "error": "Your request has been blocked due to excessive requests. Please reduce the rate of requests."
}
```

We recommend implementing retry logic that respects the `retry-after` header value to automatically handle rate limiting in your application.

<Tip>
  1. Access to production keys requires either an active **Paid Plan** or **PAYGO** enabled. More information can be found [here](/guides/api-credits).
  2. When using the REST API, ensure you include your API key in the header to apply the correct rate limits.
</Tip>


# Tavily CLI
Source: https://docs.tavily.com/documentation/tavily-cli

Search, extract, crawl, map, and research the web from your terminal.

<CardGroup>
  <Card title="PyPI" icon="python" href="https://github.com/tavily-ai/skills">
    `tavily-cli`
  </Card>

  <Card title="Get API Key" icon="key" href="https://app.tavily.com">
    Sign up at tavily.com
  </Card>
</CardGroup>

The Tavily CLI (`tvly`) brings the full Tavily API to your command line. Run web searches, extract content from URLs, crawl websites, discover sitemaps, and launch deep research — all from a single tool.

Every command supports `--json` for machine-readable output, making it easy to integrate into scripts, pipelines, and AI agent workflows.

## Installation

Install with the official installer:

```bash theme={null}
curl -fsSL https://cli.tavily.com/install.sh | bash
```

Or install manually:

```bash theme={null}
uv tool install tavily-cli   # or: pip install tavily-cli
```

Verify the install:

```bash theme={null}
tvly --version
```

## Authentication

You need a Tavily API key to use the CLI. Get one for free at [tavily.com](https://tavily.com).

<AccordionGroup>
  <Accordion title="Option 1: Login with an API key (recommended)" icon="key">
    ```bash theme={null}
    tvly login --api-key tvly-YOUR_API_KEY
    ```

    This stores your key in `~/.tavily/config.json` (readable only by your user).
  </Accordion>

  <Accordion title="Option 2: Browser-based OAuth" icon="browser">
    ```bash theme={null}
    tvly login
    ```

    This opens your browser for authentication. Tokens are stored in `~/.mcp-auth/`.

    <Note>OAuth login requires Node.js/npx to be available on your system.</Note>
  </Accordion>

  <Accordion title="Option 3: Environment variable" icon="code">
    ```bash theme={null}
    export TAVILY_API_KEY=tvly-YOUR_API_KEY
    ```
  </Accordion>
</AccordionGroup>

### Check Your Auth Status

```bash theme={null}
tvly auth
```

### Log Out

```bash theme={null}
tvly logout
```

This removes stored credentials from disk.

## Session Tracking

The CLI automatically attaches a unique `session_id` to every command it runs, so requests from the same shell invocation can be grouped together. This applies to `tvly search`, `extract`, `crawl`, `map`, and `research`.

To also associate requests with a specific end-user, set the `TAVILY_HUMAN_ID` environment variable:

```bash theme={null}
export TAVILY_HUMAN_ID=h_4f9ac
```

Alternatively, add a `human_id` field to `~/.tavily/config.json` — the environment variable takes precedence if both are set.

For security, Tavily hashes human IDs before processing or storing them. See [Session Tracking](/documentation/api-reference/introduction#session--user-tracking) in the API reference for details.

## Commands

<AccordionGroup>
  <Accordion title="tvly search" icon="magnifying-glass">
    Search the web using Tavily's AI-optimized search engine.

    ```bash theme={null}
    tvly search "your search query"
    ```

    **Reading from stdin:**

    ```bash theme={null}
    echo "your query" | tvly search -
    ```

    #### Options

    | Option                         | Type                                            | Default   | Description                                                                |
    | ------------------------------ | ----------------------------------------------- | --------- | -------------------------------------------------------------------------- |
    | `--depth`                      | `ultra-fast` \| `fast` \| `basic` \| `advanced` | `basic`   | Search depth. Higher depth returns more detailed results.                  |
    | `--max-results`                | `0–20`                                          | `5`       | Number of results to return.                                               |
    | `--topic`                      | `general` \| `news` \| `finance`                | `general` | Optimize search for a specific topic.                                      |
    | `--time-range`                 | `day` \| `week` \| `month` \| `year`            | —         | Filter results to a relative time window.                                  |
    | `--start-date`                 | `YYYY-MM-DD`                                    | —         | Only include results published after this date.                            |
    | `--end-date`                   | `YYYY-MM-DD`                                    | —         | Only include results published before this date.                           |
    | `--include-domains`            | comma-separated                                 | —         | Restrict results to these domains.                                         |
    | `--exclude-domains`            | comma-separated                                 | —         | Exclude results from these domains.                                        |
    | `--country`                    | country code                                    | —         | Boost results from a specific country.                                     |
    | `--include-answer`             | `basic` \| `advanced`                           | —         | Include an AI-generated answer with results.                               |
    | `--include-raw-content`        | `markdown` \| `text`                            | —         | Include full page content for each result.                                 |
    | `--include-images`             | flag                                            | `false`   | Include image results.                                                     |
    | `--include-image-descriptions` | flag                                            | `false`   | Include AI-generated image descriptions.                                   |
    | `--chunks-per-source`          | integer                                         | —         | Number of content chunks per source (requires `fast` or `advanced` depth). |
    | `-o` / `--output`              | file path                                       | —         | Save output to a file.                                                     |
    | `--json`                       | flag                                            | `false`   | Output raw JSON.                                                           |

    #### Examples

    ```bash theme={null}
    # Basic search
    tvly search "best programming languages 2025"

    # News from the past week
    tvly search "AI regulation" --topic news --time-range week

    # Advanced search with AI answer
    tvly search "how does transformer architecture work" --depth advanced --include-answer advanced

    # Restrict to specific sites
    tvly search "python tutorials" --include-domains realpython.com,docs.python.org

    # Save results to a file
    tvly search "climate change data" -o results.txt
    ```
  </Accordion>

  <Accordion title="tvly extract" icon="file-lines">
    Extract clean, readable content from one or more URLs.

    ```bash theme={null}
    tvly extract <url> [<url> ...]
    ```

    You can pass up to 20 URLs at once.

    #### Options

    | Option                | Type                  | Default    | Description                                                     |
    | --------------------- | --------------------- | ---------- | --------------------------------------------------------------- |
    | `--query`             | string                | —          | Rerank extracted chunks by relevance to this query.             |
    | `--chunks-per-source` | `1–5`                 | —          | Number of content chunks per URL (requires `--query`).          |
    | `--extract-depth`     | `basic` \| `advanced` | `basic`    | Extraction depth. `advanced` handles JavaScript-rendered pages. |
    | `--format`            | `markdown` \| `text`  | `markdown` | Output format for extracted content.                            |
    | `--include-images`    | flag                  | `false`    | Include image URLs found on the page.                           |
    | `--timeout`           | `1–60`                | —          | Maximum wait time in seconds.                                   |
    | `-o` / `--output`     | file path             | —          | Save output to a file.                                          |
    | `--json`              | flag                  | `false`    | Output raw JSON.                                                |

    #### Examples

    ```bash theme={null}
    # Extract content from a URL
    tvly extract https://example.com/article

    # Extract multiple URLs
    tvly extract https://example.com/page1 https://example.com/page2

    # Extract with relevance filtering
    tvly extract https://docs.python.org/3/tutorial/ --query "list comprehensions" --chunks-per-source 3

    # Extract JavaScript-rendered content
    tvly extract https://example.com/spa-page --extract-depth advanced
    ```
  </Accordion>

  <Accordion title="tvly crawl" icon="spider-web">
    Crawl a website starting from a URL and extract content from every discovered page.

    ```bash theme={null}
    tvly crawl <url>
    ```

    #### Options

    | Option                               | Type                  | Default    | Description                                                                          |
    | ------------------------------------ | --------------------- | ---------- | ------------------------------------------------------------------------------------ |
    | `--max-depth`                        | `1–5`                 | `1`        | How many levels deep to crawl from the start URL.                                    |
    | `--max-breadth`                      | integer               | `20`       | Maximum links to follow per page.                                                    |
    | `--limit`                            | integer               | `50`       | Total page cap for the crawl.                                                        |
    | `--instructions`                     | string                | —          | Natural language guidance for the crawler (e.g., "only follow documentation pages"). |
    | `--chunks-per-source`                | `1–5`                 | —          | Chunks per page (requires `--instructions`).                                         |
    | `--extract-depth`                    | `basic` \| `advanced` | `basic`    | Extraction depth for crawled pages.                                                  |
    | `--format`                           | `markdown` \| `text`  | `markdown` | Output format for extracted content.                                                 |
    | `--select-paths`                     | comma-separated regex | —          | Only crawl paths matching these patterns.                                            |
    | `--exclude-paths`                    | comma-separated regex | —          | Skip paths matching these patterns.                                                  |
    | `--select-domains`                   | comma-separated regex | —          | Only follow links to matching domains.                                               |
    | `--exclude-domains`                  | comma-separated regex | —          | Skip links to matching domains.                                                      |
    | `--allow-external` / `--no-external` | flag                  | —          | Whether to follow links to external domains.                                         |
    | `--include-images`                   | flag                  | `false`    | Include images found on pages.                                                       |
    | `--timeout`                          | `10–150`              | —          | Maximum wait time in seconds.                                                        |
    | `-o` / `--output`                    | file path             | —          | Save full JSON output to a file.                                                     |
    | `--output-dir`                       | directory path        | —          | Save each crawled page as a separate `.md` file.                                     |
    | `--json`                             | flag                  | `false`    | Output raw JSON.                                                                     |

    #### Examples

    ```bash theme={null}
    # Crawl a docs site (1 level deep)
    tvly crawl https://docs.example.com

    # Deep crawl with a page limit
    tvly crawl https://docs.example.com --max-depth 3 --limit 100

    # Crawl only blog posts
    tvly crawl https://example.com --select-paths "/blog/.*"

    # Save each page as a markdown file
    tvly crawl https://docs.example.com --output-dir ./docs-mirror

    # Guided crawl
    tvly crawl https://docs.example.com --instructions "focus on API reference pages"
    ```
  </Accordion>

  <Accordion title="tvly map" icon="sitemap">
    Discover all URLs on a website without extracting content. Useful for building sitemaps or understanding site structure.

    ```bash theme={null}
    tvly map <url>
    ```

    #### Options

    | Option                               | Type                  | Default | Description                                     |
    | ------------------------------------ | --------------------- | ------- | ----------------------------------------------- |
    | `--max-depth`                        | `1–5`                 | `1`     | How many levels deep to discover links.         |
    | `--max-breadth`                      | integer               | `20`    | Maximum links to follow per page.               |
    | `--limit`                            | integer               | `50`    | Maximum total URLs to discover.                 |
    | `--instructions`                     | string                | —       | Natural language guidance for URL discovery.    |
    | `--select-paths`                     | comma-separated regex | —       | Only include URLs matching these path patterns. |
    | `--exclude-paths`                    | comma-separated regex | —       | Exclude URLs matching these path patterns.      |
    | `--select-domains`                   | comma-separated regex | —       | Only include URLs from matching domains.        |
    | `--exclude-domains`                  | comma-separated regex | —       | Exclude URLs from matching domains.             |
    | `--allow-external` / `--no-external` | flag                  | —       | Whether to include external domain links.       |
    | `--timeout`                          | `10–150`              | —       | Maximum wait time in seconds.                   |
    | `-o` / `--output`                    | file path             | —       | Save output to a file.                          |
    | `--json`                             | flag                  | `false` | Output raw JSON.                                |

    #### Examples

    ```bash theme={null}
    # Discover URLs on a site
    tvly map https://example.com

    # Deep URL discovery
    tvly map https://docs.example.com --max-depth 3 --limit 200

    # Only find API doc URLs
    tvly map https://docs.example.com --select-paths "/api/.*"

    # Save URL list to a file
    tvly map https://example.com -o urls.txt
    ```
  </Accordion>

  <Accordion title="tvly research" icon="magnifying-glass-chart">
    Launch deep, multi-step research on any topic. Tavily's research engine searches the web, synthesizes sources, and produces a comprehensive report with citations.

    ```bash theme={null}
    tvly research "your research topic"
    ```

    This is equivalent to `tvly research run "your research topic"`.

    **Reading from stdin:**

    ```bash theme={null}
    echo "your topic" | tvly research -
    ```

    #### Options

    | Option              | Type                                      | Default | Description                                                                          |
    | ------------------- | ----------------------------------------- | ------- | ------------------------------------------------------------------------------------ |
    | `--model`           | `mini` \| `pro` \| `auto`                 | `auto`  | Research model. `mini` is faster, `pro` is more thorough, `auto` picks the best fit. |
    | `--no-wait`         | flag                                      | `false` | Return the `request_id` immediately without waiting for completion.                  |
    | `--stream`          | flag                                      | `false` | Stream results in real-time as the research progresses.                              |
    | `--output-schema`   | file path                                 | —       | Path to a JSON schema file for structured output.                                    |
    | `--citation-format` | `numbered` \| `mla` \| `apa` \| `chicago` | —       | Citation style for the research report.                                              |
    | `--poll-interval`   | seconds                                   | `10`    | How often to check for completion.                                                   |
    | `--timeout`         | seconds                                   | `600`   | Maximum time to wait for results.                                                    |
    | `-o` / `--output`   | file path                                 | —       | Save the report to a file.                                                           |
    | `--json`            | flag                                      | `false` | Output raw JSON.                                                                     |

    #### Subcommands

    **Check status of a running research task:**

    ```bash theme={null}
    tvly research status <request_id>
    ```

    **Poll a research task until it completes:**

    ```bash theme={null}
    tvly research poll <request_id>
    ```

    The `poll` subcommand accepts `--poll-interval`, `--timeout`, `-o`, and `--json`.

    #### Examples

    ```bash theme={null}
    # Quick research
    tvly research "comparison of React vs Vue in 2025"

    # Thorough research with the pro model
    tvly research "impact of AI on healthcare" --model pro

    # Stream results as they come in
    tvly research "quantum computing breakthroughs" --stream

    # Fire-and-forget: get the ID, poll later
    tvly research "market analysis of EVs" --no-wait
    # ... later:
    tvly research poll <request_id>

    # Save the report to a file with APA citations
    tvly research "effects of remote work on productivity" --citation-format apa -o report.md
    ```
  </Accordion>
</AccordionGroup>

## Interactive Mode

Run `tvly` with no arguments to enter an interactive REPL where you can run commands without the `tvly` prefix:

```bash theme={null}
tvly
```

```
❯ search "latest AI news"
❯ extract https://example.com
❯ exit
```

## Global Options

These options work with the top-level `tvly` command:

| Option      | Description                                             |
| ----------- | ------------------------------------------------------- |
| `--version` | Print the CLI version and exit.                         |
| `--status`  | Print the version and authentication status.            |
| `--json`    | Output as JSON (applies to `--version` and `--status`). |
| `--help`    | Show help for any command.                              |

```bash theme={null}
tvly --version
tvly --status
tvly search --help
```

## JSON Mode

Add `--json` to any command to get machine-readable JSON output. This is useful for piping into other tools like `jq`, or for integration with scripts and AI agents.

```bash theme={null}
# Pipe search results through jq
tvly search "AI news" --json | jq '.results[].title'

# Use in a shell script
RESULTS=$(tvly search "latest papers on RAG" --json)
```

All human-readable output (spinners, status messages) is written to stderr, so stdout contains only the clean JSON when `--json` is used.

## Environment Variables

| Variable         | Description                                                    |
| ---------------- | -------------------------------------------------------------- |
| `TAVILY_API_KEY` | Your Tavily API key. Takes precedence over stored credentials. |

<Accordion title="Exit Codes">
  | Code | Meaning                                                         |
  | ---- | --------------------------------------------------------------- |
  | `0`  | Success.                                                        |
  | `2`  | Invalid input or usage error (e.g., missing required argument). |
  | `3`  | Authentication error (no API key found, or login failed).       |
  | `4`  | API error (rate limit, invalid request, server error).          |
</Accordion>

## Uninstall

```bash theme={null}
pip uninstall tavily-cli
```

To also remove stored credentials:

```bash theme={null}
rm -rf ~/.tavily ~/.mcp-auth
```


# Chatbot
Source: https://docs.tavily.com/examples/agent-toolkit/chatbot

Build a conversational chatbot that routes between quick web search and deep research based on query complexity.

## What You'll Build

An interactive chatbot that uses Tavily tools to answer questions with real-time web data. It dynamically chooses between lightweight search (for simple factual questions) and deep research (for complex, multi-source analysis) — then synthesizes answers with numbered citations.

<Card title="View Source on GitHub" icon="github" href="https://github.com/tavily-ai/tavily-cookbook/tree/main/agent-toolkit/use-cases" />

## Architecture

```mermaid theme={null}
flowchart TD
    A[User Query] --> B[LLM Agent]
    B --> C{Query Complexity?}
    C -->|Simple question| D[search_and_format]
    C -->|Complex question| E[stream_research]
    D --> F{Enough info?}
    F -->|No| D
    F -->|Yes| G[Generate Response + Citations]
    E --> G
    G --> H[User Response]
```

**Key behavior:**

* The agent can call `search_and_format` **multiple times** until it has enough information
* The agent can only call `stream_research` **once** per query (comprehensive but expensive)
* All responses include numbered citations linking to sources

## Tools Used

| Tool                | When Used                                                    | Description                                                     |
| ------------------- | ------------------------------------------------------------ | --------------------------------------------------------------- |
| `search_and_format` | Simple, factual questions ("What is the capital of France?") | Runs parallel web searches and returns formatted results        |
| `stream_research`   | Complex queries requiring analysis, comparisons, or trends   | Uses Tavily's deep research endpoint for multi-source synthesis |

## Quick Start

<Tabs>
  <Tab title="Anthropic SDK">
    <Card title="Source File" icon="github" href="https://github.com/tavily-ai/tavily-cookbook/tree/main/agent-toolkit/use-cases/claude_sdk/chatbot.py" />

    ```bash theme={null}
    pip install tavily-agent-toolkit anthropic tavily-python python-dotenv
    ```

    ```bash theme={null}
    export TAVILY_API_KEY="your-tavily-api-key"
    export ANTHROPIC_API_KEY="your-anthropic-api-key"
    ```

    ```bash theme={null}
    python chatbot.py
    ```
  </Tab>

  <Tab title="LangGraph">
    <Card title="Source File" icon="github" href="https://github.com/tavily-ai/tavily-cookbook/tree/main/agent-toolkit/use-cases/langgraph/chatbot.py" />

    ```bash theme={null}
    pip install tavily-agent-toolkit langchain langchain-openai tavily-python python-dotenv
    ```

    ```bash theme={null}
    export TAVILY_API_KEY="your-tavily-api-key"
    export OPENAI_API_KEY="your-openai-api-key"
    ```

    ```bash theme={null}
    python chatbot.py
    ```
  </Tab>
</Tabs>

## How It Works

<AccordionGroup>
  <Accordion title="Tool Definitions">
    The chatbot exposes two tools to the LLM. The agent decides which to call based on the query:

    * **`search_and_format`** — wraps `tavily_agent_toolkit.search_and_format` to run parallel web searches across one or more queries. Accepts an optional `time_range` filter.
    * **`stream_research`** — calls Tavily's research API in streaming mode via `tavily_agent_toolkit.handle_research_stream`, returning a comprehensive report.
  </Accordion>

  <Accordion title="Routing Logic">
    The system prompt instructs the agent to pick the right tool:

    ```
    For simple questions, use search_and_format.
    For complex questions, use stream_research.

    You can call search_and_format multiple times.
    You can only use stream_research ONCE.
    ```

    This keeps costs low for quick lookups while enabling deep research when needed.
  </Accordion>

  <Accordion title="Agent Loop">
    The chatbot runs a standard agent loop:

    1. Send the user message + tool definitions to the LLM
    2. If the LLM returns a tool call, execute it and feed the result back
    3. Repeat until the LLM returns a final text response
    4. Print the response with citations and continue the conversation
  </Accordion>

  <Accordion title="Citation Handling">
    The system prompt enforces citation discipline:

    ```
    Use numbered in-text citations [1], [2], etc.
    At the end, include a "Sources:" section with only
    the sources you actually cited.
    Format: [number] Title - URL
    ```
  </Accordion>
</AccordionGroup>

## Example Interaction

```text theme={null}
Chatbot ready! Type 'quit' to exit.

You: What are the latest developments in quantum computing?
[Using stream_research...]
Assistant: Recent developments in quantum computing include several
breakthroughs. Google's Willow chip demonstrated error correction
below the threshold needed for practical quantum computing [1].
Microsoft announced its Majorana 1 chip using topological qubits [2].
IBM continues to expand its quantum roadmap with plans for 100,000+
qubit systems by 2033 [3].

Sources:
[1] Google Quantum AI Blog - https://blog.google/technology/research/...
[2] Microsoft Research - https://www.microsoft.com/en-us/research/...
[3] IBM Research - https://research.ibm.com/blog/...

You: Who is the CEO of Apple?
[Using search_and_format...]
Assistant: Tim Cook is the CEO of Apple [1]. He has held the position
since August 2011, succeeding Steve Jobs.

Sources:
[1] Apple Leadership - https://www.apple.com/leadership/tim-cook/
```

## Key Parameters to Tune

| Parameter     | Where               | Effect                                                             |
| ------------- | ------------------- | ------------------------------------------------------------------ |
| `model`       | Agent creation      | Controls reasoning quality and cost                                |
| `max_results` | `search_and_format` | Number of search results per query (default: 5)                    |
| `model`       | `research` call     | `"mini"` for faster, `"default"` for more thorough                 |
| `time_range`  | `search_and_format` | Filter results by recency (`"day"`, `"week"`, `"month"`, `"year"`) |

## Next Steps

<CardGroup>
  <Card title="Tools Reference" icon="wrench" href="/examples/agent-toolkit/tools">
    Full parameter docs for search\_and\_format and all other tools.
  </Card>

  <Card title="Company Intelligence" icon="building" href="/examples/agent-toolkit/company-intelligence">
    Add website crawling and extraction to your agent's capabilities.
  </Card>
</CardGroup>


# Company Intelligence
Source: https://docs.tavily.com/examples/agent-toolkit/company-intelligence

Build a research agent that crawls company websites, extracts content, and searches the web for comprehensive company analysis.

## What You'll Build

A ReAct agent that conducts comprehensive research on any company by combining website crawling with targeted web search. Give it a company name, website URL, and optional research focus — it autonomously crawls the site, extracts key pages, searches for external coverage, and produces a cited research report.

<Card title="View Source on GitHub" icon="github" href="https://github.com/tavily-ai/tavily-cookbook/tree/main/agent-toolkit/use-cases" />

## Architecture

```mermaid theme={null}
flowchart TD
    A["User Input: Company + URL + Focus"] --> B[ReAct Agent]
    B --> C[crawl_company_website]
    B --> D[extract_from_urls]
    B --> E[tavily_search]
    C -->|"Site pages + summary"| B
    D -->|"Extracted content"| B
    E -->|"News, funding, reviews"| B
    B --> F{Enough info?}
    F -->|No| B
    F -->|Yes| G["Research Report + Citations"]
```

The agent autonomously decides which tools to use and in what order. A typical research flow:

1. Crawl the company website to discover and summarize pages
2. Extract detailed content from specific URLs found during crawling
3. Search the web for external information (news, funding, reviews, competitors)
4. Synthesize everything into a structured report with citations

## Tools Used

| Tool                    | Purpose                                     | Tavily Toolkit Function |
| ----------------------- | ------------------------------------------- | ----------------------- |
| `crawl_company_website` | Crawl and summarize company website pages   | `crawl_and_summarize`   |
| `extract_from_urls`     | Extract detailed content from specific URLs | `extract_and_summarize` |
| `tavily_search`         | Search the web for external information     | `search_dedup`          |

## Quick Start

<Tabs>
  <Tab title="Anthropic SDK">
    <Card title="Source File" icon="github" href="https://github.com/tavily-ai/tavily-cookbook/tree/main/agent-toolkit/use-cases/claude_sdk/company_intelligence_deep_agent.py" />

    ```bash theme={null}
    pip install tavily-agent-toolkit anthropic claude-agent-sdk python-dotenv
    ```

    ```bash theme={null}
    export TAVILY_API_KEY="your-tavily-api-key"
    export ANTHROPIC_API_KEY="your-anthropic-api-key"
    ```

    ```bash theme={null}
    python company_intelligence_deep_agent.py
    ```
  </Tab>

  <Tab title="LangGraph">
    <Card title="Source File" icon="github" href="https://github.com/tavily-ai/tavily-cookbook/tree/main/agent-toolkit/use-cases/langgraph/company_intelligence_deep_agent.py" />

    ```bash theme={null}
    pip install tavily-agent-toolkit langchain langchain-openai python-dotenv
    ```

    ```bash theme={null}
    export TAVILY_API_KEY="your-tavily-api-key"
    export OPENAI_API_KEY="your-openai-api-key"
    ```

    ```bash theme={null}
    python company_intelligence_deep_agent.py
    ```
  </Tab>
</Tabs>

## How It Works

<AccordionGroup>
  <Accordion title="Tool Wiring">
    Each tool wraps a Tavily Agent Toolkit function with agent-friendly parameters:

    * **`crawl_company_website`** calls `crawl_and_summarize` with the company URL, optional extraction instructions, and depth/breadth controls. Returns a summarized overview of the crawled pages.
    * **`extract_from_urls`** calls `extract_and_summarize` with specific URLs and an optional query focus. Uses `extract_depth="advanced"` for full content extraction.
    * **`tavily_search`** calls `search_dedup` with multiple queries in parallel, returning deduplicated and formatted results with `search_depth="advanced"`.
  </Accordion>

  <Accordion title="System Prompt">
    The agent is prompted as a business intelligence analyst:

    ```text theme={null}
    You are a business intelligence analyst researching companies.

    You have three tools available:
    - crawl_company_website - Crawl a company's website
    - extract_from_urls - Extract content from specific URLs
    - tavily_search - Search the web for news, funding, reviews

    Combine website insights with external sources for a
    complete picture. Include citations [1], [2], etc.
    ```
  </Accordion>

  <Accordion title="Streaming Progress">
    Both implementations stream tool calls as they happen, so you can see the agent's progress in real time:

    ```text theme={null}
    [1] Crawling website -> https://anthropic.com
    [2] Searching the web -> 3 query/queries
    [3] Extracting URLs -> 2 URL(s)
    ```
  </Accordion>

  <Accordion title="Summarizer Model">
    The `crawl_and_summarize` and `extract_and_summarize` tools use a dedicated summarizer model (configured via `ModelConfig`). In the examples, a smaller model is used for summarization to keep costs low while the main agent model handles reasoning.
  </Accordion>
</AccordionGroup>

## Example Interaction

```text theme={null}
============================================================
Company Intelligence Research Agent
============================================================

Company name: Anthropic
Website URL:  https://anthropic.com
Research focus: leadership team and recent funding

------------------------------------------------------------
Researching Anthropic (https://anthropic.com)
Focus: leadership team and recent funding
------------------------------------------------------------

[1] Crawling website -> https://anthropic.com
[2] Searching the web -> 3 query/queries
[3] Extracting URLs -> 2 URL(s)

Completed in 23.4s | 4 turns

============================================================
RESEARCH REPORT
============================================================

Anthropic is an AI safety company founded in 2021...
[Comprehensive report with citations]
```

## Example Research Topics

* Company overview and products
* Leadership team and organizational structure
* Recent funding rounds and investors
* Competitive landscape
* Customer reviews and reputation
* Technology stack and engineering culture

## Key Parameters to Tune

| Parameter       | Where                   | Effect                                           |
| --------------- | ----------------------- | ------------------------------------------------ |
| `max_depth`     | `crawl_company_website` | How deep to crawl from the homepage (default: 2) |
| `max_breadth`   | `crawl_company_website` | Pages per crawl level (default: 10)              |
| `limit`         | `crawl_company_website` | Total page cap (default: 20)                     |
| `extract_depth` | `extract_from_urls`     | `"basic"` or `"advanced"` for full content       |
| `max_results`   | `tavily_search`         | Results per search query (default: 5)            |
| `topic`         | `tavily_search`         | `"general"`, `"news"`, or `"finance"`            |

## Next Steps

<CardGroup>
  <Card title="Social Media Research" icon="hashtag" href="/examples/agent-toolkit/social-media-research">
    Add social media intelligence to your agent with platform-specific search.
  </Card>

  <Card title="Hybrid Research" icon="flask" href="/examples/agent-toolkit/hybrid-research">
    Combine internal company data with web research for deeper analysis.
  </Card>
</CardGroup>


# Hybrid Research
Source: https://docs.tavily.com/examples/agent-toolkit/hybrid-research

Combine your internal knowledge base with real-time web research to produce comprehensive, grounded reports.

## What You'll Build

A research agent that merges your internal data (from a vector store, database, or any retrieval system) with live web research from Tavily. You provide a simple RAG function — the agent identifies gaps in your internal knowledge and fills them with web data, producing a comprehensive report with citations.

<Card title="View Source on GitHub" icon="github" href="https://github.com/tavily-ai/tavily-cookbook/tree/main/agent-toolkit/agents" />

## Why Hybrid Research?

Your internal data is your competitive edge — customer records, product specs, domain expertise. But it's never complete. Markets shift, competitors launch products, and your knowledge base can't keep up.

The hybrid approach gives you:

* **Grounded answers** rooted in your proprietary data
* **Complete coverage** with real-time web context
* **Enrichment opportunities** by storing relevant web findings back into your knowledge base

## Modes

<Tabs>
  <Tab title="Fast Mode">
    Best for quick answers, lower latency, and cost-sensitive applications.

    ```mermaid theme={null}
    flowchart LR
        A[Query] --> B[Internal RAG]
        B --> C[Generate Subqueries]
        C --> D["Parallel Web Search + Dedup"]
        B --> E[Synthesize]
        D --> E
        E --> F["Report + Sources"]
    ```

    1. Query your internal RAG
    2. Generate subqueries based on what's missing
    3. Parallel web search with deduplication
    4. Synthesize everything into a report

    ```python theme={null}
    from tavily_agent_toolkit import hybrid_research, ModelConfig, ModelObject

    def my_rag(query: str) -> str:
        results = vector_store.similarity_search(query, k=5)
        return "\n".join([doc.page_content for doc in results])

    result = await hybrid_research(
        api_key="tvly-xxx",
        query="What's our competitor's current pricing strategy?",
        model_config=ModelConfig(
            model=ModelObject(model="openai:gpt-5.2")
        ),
        internal_rag_function=my_rag,
        mode="fast",
    )

    print(result["report"])
    print(f"Sources: {len(result['web_sources'])} web pages")
    ```
  </Tab>

  <Tab title="Multi-Agent Mode">
    Best for comprehensive research, complex topics, and when accuracy matters more than speed.

    This mode uses Tavily's deep research endpoint — a multi-agent system that orchestrates sub-agents to iteratively search, extract, and analyze.

    ```mermaid theme={null}
    flowchart TD
        A[Query] --> B["Agent 1: Internal RAG"]
        B --> C[Identify Knowledge Gaps]
        C --> D["Agent 2: Tavily Deep Research"]
        D --> E["Sub-agents: search, extract, analyze, iterate"]
        E --> F["Synthesize Internal + Web"]
        F --> G["Report + Sources"]
    ```

    1. Query your internal RAG
    2. LLM identifies knowledge gaps
    3. Tavily's deep research endpoint fills those gaps
    4. Synthesize into a comprehensive report

    ```python theme={null}
    result = await hybrid_research(
        api_key="tvly-xxx",
        query="Full competitive analysis of the AI search market",
        model_config=ModelConfig(
            model=ModelObject(model="anthropic:claude-sonnet-4-20250514")
        ),
        internal_rag_function=my_rag,
        mode="multi_agent",
    )
    ```
  </Tab>
</Tabs>

## Parameters

| Parameter                   | Type         | Default  | Description                                                     |
| --------------------------- | ------------ | -------- | --------------------------------------------------------------- |
| `api_key`                   | str          | Required | Tavily API key                                                  |
| `query`                     | str          | Required | The research question                                           |
| `model_config`              | ModelConfig  | Required | Your LLM configuration                                          |
| `internal_rag_function`     | Callable     | Required | Function that takes a query string and returns relevant context |
| `mode`                      | str          | `"fast"` | `"fast"` or `"multi_agent"`                                     |
| `output_schema`             | OutputSchema | None     | Pydantic model for structured output                            |
| `research_synthesis_prompt` | str          | None     | Custom instructions for how the report is structured            |

### Return Value

```python theme={null}
{
    "report": str | BaseModel,  # Synthesized report (or structured output)
    "web_sources": [            # Sources used from web research
        {"title": "...", "url": "..."},
        ...
    ]
}
```

## Structured Output

Use `output_schema` to get consistent, parseable results:

```python theme={null}
from pydantic import Field
from tavily_agent_toolkit import OutputSchema

class CompetitorAnalysis(OutputSchema):
    company_name: str = Field(description="Name of the competitor")
    products: list[str] = Field(description="Main products or services")
    pricing: str = Field(description="Pricing strategy or model")
    strengths: list[str] = Field(description="Key competitive strengths")
    weaknesses: list[str] = Field(description="Known weaknesses or gaps")

result = await hybrid_research(
    api_key="tvly-xxx",
    query="Analyze Perplexity as a competitor",
    model_config=ModelConfig(
        model=ModelObject(model="groq:openai/gpt-oss-120b")
    ),
    internal_rag_function=my_rag,
    mode="fast",
    output_schema=CompetitorAnalysis,
)

analysis = CompetitorAnalysis.model_validate_json(result["report"])
print(f"Strengths: {analysis.strengths}")
```

## Custom Synthesis

Guide how the report is structured with `research_synthesis_prompt`:

```python theme={null}
result = await hybrid_research(
    api_key="tvly-xxx",
    query="What are the latest developments in AI agents?",
    model_config=ModelConfig(
        model=ModelObject(model="groq:llama-3.3-70b-versatile")
    ),
    internal_rag_function=my_rag,
    mode="fast",
    research_synthesis_prompt="""
    Structure the report as:
    1. Executive Summary (2-3 sentences)
    2. Key Developments (bullet points)
    3. Impact on Our Product (specific recommendations)
    4. Sources

    Keep it under 500 words. Focus on actionable insights.
    """,
)
```

## Data Enrichment Pattern

When your agent searches the web to fill knowledge gaps, those results are relevant to your users — otherwise the agent wouldn't have needed them. This creates a flywheel:

1. Agent queries internal data and finds gaps
2. Agent searches the web to fill gaps
3. Web results get synthesized into the answer
4. **Store those web results internally** for future queries

```python theme={null}
result = await hybrid_research(...)

for source in result["web_sources"]:
    store_in_knowledge_base(
        url=source["url"],
        title=source["title"],
        query_context=original_query,
    )
```

Over time, your knowledge base grows with exactly the information your users need.

## Implementing Your RAG Function

The `internal_rag_function` is simple: take a query, return relevant context as a string.

```python theme={null}
def my_rag(query: str) -> str:
    results = your_retrieval_method(query)
    return "\n\n".join([
        f"Source: {r.source}\n{r.content}"
        for r in results
    ])
```

**Tips:**

* Return 3-10 relevant chunks — enough context without overwhelming
* Include source metadata (file names, URLs, doc IDs) for traceability
* The hybrid researcher handles the rest: gap detection, web search, synthesis

## Next Steps

<CardGroup>
  <Card title="Tools Reference" icon="wrench" href="/examples/agent-toolkit/tools">
    Deep dive into search\_and\_answer, search\_dedup, and the other retrieval primitives.
  </Card>

  <Card title="Chatbot" icon="message-bot" href="/examples/agent-toolkit/chatbot">
    See how the chatbot routes between quick search and deep research.
  </Card>
</CardGroup>


# Agent Toolkit
Source: https://docs.tavily.com/examples/agent-toolkit/overview

Build production-grade research agents with battle-tested tools, model flexibility, and pre-built agent patterns.

<CardGroup>
  <Card title="GitHub" icon="github" href="https://github.com/tavily-ai/tavily-cookbook/tree/main/agent-toolkit">
    `/tavily-ai/tavily-cookbook/agent-toolkit`
  </Card>

  <Card title="PyPI" icon="python" href="https://pypi.org/project/tavily-agent-toolkit/">
    `tavily-agent-toolkit`
  </Card>
</CardGroup>

## What Is the Agent Toolkit?

The Tavily Agent Toolkit is a Python library that gives your agents optimized research primitives on top of the Tavily API. Instead of wiring up raw API calls, managing token limits, deduplicating sources, and formatting results for LLMs yourself, the toolkit handles all of that so your agent can focus on reasoning.

It provides three layers:

| Layer                    | What It Does                                                                                                                                                   |
| ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Agents**               | Pre-built research strategies that combine internal knowledge with web research. Fast or deep multi-agent modes.                                               |
| **Tools**                | Optimized retrieval patterns: search, crawl, extract, social media. Each tool handles context engineering (formatting, dedup, token management) automatically. |
| **Bring Your Own Model** | Every tool that needs an LLM accepts a `ModelConfig`. Supports 20+ providers via LangChain with automatic fallback chains.                                     |

## Installation

```bash theme={null}
pip install tavily-agent-toolkit
```

For LLM features, install your preferred provider:

```bash theme={null}
pip install langchain-openai       # OpenAI
pip install langchain-anthropic    # Anthropic
pip install langchain-google-genai # Google
pip install langchain-groq         # Groq
```

## Available Tools

| Tool                    | When to Use                                           |
| ----------------------- | ----------------------------------------------------- |
| `search_and_answer`     | Answer questions with web research + LLM synthesis    |
| `search_dedup`          | Run multiple queries in parallel, deduplicate results |
| `crawl_and_summarize`   | Extract and summarize entire websites                 |
| `extract_and_summarize` | Get focused summaries from specific URLs              |
| `social_media_search`   | Search Reddit, X, LinkedIn, TikTok, and more          |

```python theme={null}
from tavily_agent_toolkit import search_and_answer, ModelConfig, ModelObject

result = await search_and_answer(
    query="What are the pros and cons of Rust vs Go?",
    api_key="tvly-xxx",
    model_config=ModelConfig(model=ModelObject(model="anthropic:claude-sonnet-4-5")),
    max_number_of_subqueries=3,
)
print(result["answer"])
```

<Card title="Tools Reference" icon="wrench" href="/examples/agent-toolkit/tools">
  Full documentation for every tool: parameters, output shapes, and usage examples.
</Card>

## Pre-Built Agents

### `hybrid_research`

Combines your internal knowledge base with real-time web research. You provide a RAG function that queries your internal data — the agent identifies gaps and fills them with web research.

Two modes:

| Mode            | Best For                               | How It Works                                                              |
| --------------- | -------------------------------------- | ------------------------------------------------------------------------- |
| **Fast**        | Quick answers, lower latency           | Internal RAG → generate subqueries → parallel web search → synthesize     |
| **Multi-Agent** | Comprehensive research, complex topics | Internal RAG → identify gaps → Tavily deep research endpoint → synthesize |

```python theme={null}
from tavily_agent_toolkit import hybrid_research, ModelConfig, ModelObject

result = await hybrid_research(
    api_key="tvly-xxx",
    query="What's our competitor's current pricing strategy?",
    model_config=ModelConfig(model=ModelObject(model="openai:gpt-5.2")),
    internal_rag_function=my_rag,
    mode="fast",
)
print(result["report"])
```

<Card title="Hybrid Research" icon="flask" href="/examples/agent-toolkit/hybrid-research">
  Deep dive into `hybrid_research`: modes, structured output, custom synthesis, and data enrichment patterns.
</Card>

## Model Configuration

All tools accept a `ModelConfig` for LLM operations. Use the `"provider:model"` format:

```python theme={null}
from tavily_agent_toolkit import ModelConfig, ModelObject

config = ModelConfig(
    model=ModelObject(model="openai:gpt-5.2"),
    fallback_models=[
        ModelObject(model="anthropic:claude-sonnet-4-20250514"),
        ModelObject(model="groq:llama-3.3-70b-versatile"),
    ],
    temperature=0.7,
)
```

20+ providers are supported via LangChain's `init_chat_model`: OpenAI, Anthropic, Google, Groq, Mistral, Cohere, Together, Fireworks, AWS Bedrock, Azure, and more.

## Use-Case Recipes

Production-ready agent implementations. Each is available in both Anthropic SDK and LangGraph flavors.

<CardGroup>
  <Card title="Chatbot" icon="message-bot" href="/examples/agent-toolkit/chatbot">
    Routes between quick search and deep research based on query complexity.
  </Card>

  <Card title="Company Intelligence" icon="building" href="/examples/agent-toolkit/company-intelligence">
    Crawls websites and searches the web for comprehensive company research.
  </Card>

  <Card title="Social Media Research" icon="hashtag" href="/examples/agent-toolkit/social-media-research">
    Searches across TikTok, Reddit, X, LinkedIn, and more for any topic.
  </Card>

  <Card title="Hybrid Research" icon="flask" href="/examples/agent-toolkit/hybrid-research">
    Combines internal data with web research for comprehensive reports.
  </Card>
</CardGroup>


# Social Media Research
Source: https://docs.tavily.com/examples/agent-toolkit/social-media-research

Build an agent that searches across TikTok, Reddit, X, LinkedIn, and more to research any topic from social media.

## What You'll Build

A general-purpose research agent that searches across social media platforms — TikTok, Reddit, Instagram, X, Facebook, and LinkedIn — to gather real-world opinions, discussions, and insights on any topic. The agent strategically targets different platforms based on the kind of information it needs and synthesizes findings into a cited report.

<Card title="View Source on GitHub" icon="github" href="https://github.com/tavily-ai/tavily-cookbook/tree/main/agent-toolkit/use-cases" />

## Architecture

```mermaid theme={null}
flowchart TD
    A[User Query] --> B[LLM Agent]
    B --> C[search_social_media]
    C -->|"Reddit: honest opinions"| D[Results]
    C -->|"TikTok: trends"| D
    C -->|"X: real-time reactions"| D
    C -->|"LinkedIn: professional takes"| D
    C -->|"Combined: all platforms"| D
    D --> B
    B --> E{Complete picture?}
    E -->|No, try another platform| C
    E -->|Yes| F["Report + Citations"]
```

The agent calls `search_social_media` multiple times with different queries and platform targets to build a complete picture before synthesizing.

## Tools Used

| Tool                  | Platforms                                                     | Description                                                                                                     |
| --------------------- | ------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| `search_social_media` | TikTok, Instagram, Reddit, X, Facebook, LinkedIn, or combined | Searches social platforms with platform-specific targeting, time filtering, and optional raw content extraction |

The agent can customize each search call with:

* **`platform`** — target a specific platform or search all with `"combined"`
* **`max_results`** — control how many results to fetch
* **`time_range`** — filter by `"day"`, `"week"`, `"month"`, or `"year"`
* **`include_raw_content`** — extract full post content for deeper analysis

## Quick Start

<Tabs>
  <Tab title="Anthropic SDK">
    <Card title="Source File" icon="github" href="https://github.com/tavily-ai/tavily-cookbook/tree/main/agent-toolkit/use-cases/claude_sdk/social_media_research.py" />

    ```bash theme={null}
    pip install tavily-agent-toolkit anthropic tavily-python python-dotenv
    ```

    ```bash theme={null}
    export TAVILY_API_KEY="your-tavily-api-key"
    export ANTHROPIC_API_KEY="your-anthropic-api-key"
    ```

    ```bash theme={null}
    python social_media_research.py
    ```
  </Tab>

  <Tab title="LangGraph">
    <Card title="Source File" icon="github" href="https://github.com/tavily-ai/tavily-cookbook/tree/main/agent-toolkit/use-cases/langgraph/social_media_research.py" />

    ```bash theme={null}
    pip install tavily-agent-toolkit langchain langchain-openai tavily-python python-dotenv
    ```

    ```bash theme={null}
    export TAVILY_API_KEY="your-tavily-api-key"
    export OPENAI_API_KEY="your-openai-api-key"
    ```

    ```bash theme={null}
    python social_media_research.py
    ```
  </Tab>
</Tabs>

## How It Works

<AccordionGroup>
  <Accordion title="Platform Strategy">
    The system prompt guides the agent to use platforms strategically:

    ```text theme={null}
    Reddit is great for honest opinions
    TikTok for trends
    X for real-time reactions
    LinkedIn for professional takes
    ```

    The agent typically makes 2-4 search calls, targeting different platforms or using different query angles to build comprehensive coverage.
  </Accordion>

  <Accordion title="Tool Configuration">
    The `search_social_media` tool wraps `tavily_agent_toolkit.social_media_search` with these defaults:

    * `search_depth="advanced"` for thorough content extraction
    * `include_answer=True` to get an AI-synthesized summary alongside raw results
    * `time_range="month"` as a sensible default for recency

    The agent can override these per-call based on what it needs.
  </Accordion>

  <Accordion title="Synthesis and Citations">
    After gathering results from multiple platforms, the agent synthesizes findings into a clear report with inline citations `[1]`, `[2]` and a sources list with URLs at the end.
  </Accordion>
</AccordionGroup>

## Example Interaction

```text theme={null}
============================================================
Social Media Research Agent
============================================================

This agent searches across TikTok, Reddit, Instagram, X,
Facebook, and LinkedIn to research any topic.

What would you like to research?
> What are people saying about the new iPhone?
------------------------------------------------------------
Researching...

[Searching social media on reddit...]
[Searching social media on x...]
[Searching social media on tiktok...]

============================================================
REPORT
============================================================

The new iPhone has generated significant discussion across
social media platforms. On Reddit, users are largely positive
about the camera improvements [1] but divided on the pricing [2].
TikTok creators have been showcasing the new camera features
with comparisons to previous models [3]. On X, the real-time
reaction has been mixed, with praise for performance but
criticism of incremental updates [4]...

Sources:
[1] r/apple - "iPhone 16 Pro Max camera review" - https://...
[2] r/iphone - "Is the upgrade worth it?" - https://...
[3] TikTok - @techreviewer - https://...
[4] X - @mkbhd - https://...
```

## Example Research Topics

* Product reviews and sentiment ("What do people think of the Dyson Airwrap?")
* Trending discussions ("What's viral on TikTok this week?")
* Public opinion ("How do people feel about remote work?")
* Event reactions ("What are people saying about the Super Bowl?")
* Travel recommendations ("Best hiking spots according to Reddit?")
* Brand perception ("How is Company X perceived on LinkedIn vs Reddit?")

## Key Parameters to Tune

| Parameter             | Effect                                                                                                         |
| --------------------- | -------------------------------------------------------------------------------------------------------------- |
| `platform`            | Target a specific platform or `"combined"` for all. Use `"reddit"` for honest opinions, `"tiktok"` for trends. |
| `max_results`         | Number of results per search call (default: 10)                                                                |
| `time_range`          | `"day"` for breaking news, `"month"` for broader trends                                                        |
| `include_raw_content` | `true` for full post text, `false` for snippets only                                                           |

## Next Steps

<CardGroup>
  <Card title="Company Intelligence" icon="building" href="/examples/agent-toolkit/company-intelligence">
    Combine social media research with website crawling for full company analysis.
  </Card>

  <Card title="Tools Reference" icon="wrench" href="/examples/agent-toolkit/tools">
    Full documentation for social\_media\_search and all other tools.
  </Card>
</CardGroup>


# Tools Reference
Source: https://docs.tavily.com/examples/agent-toolkit/tools

Optimized retrieval primitives for research agents: search, crawl, extract, and social media.

Each tool combines Tavily API endpoints with context engineering — formatting results for LLMs, managing token limits, deduplicating sources, and cleaning web noise. Your agent focuses on reasoning while the tools handle retrieval complexity.

| Scenario                                    | Tool                    |
| ------------------------------------------- | ----------------------- |
| "Answer this question with web research"    | `search_and_answer`     |
| "Research this topic from multiple angles"  | `search_dedup`          |
| "What does this website say?"               | `crawl_and_summarize`   |
| "Summarize these specific pages"            | `extract_and_summarize` |
| "What are people saying on Reddit/Twitter?" | `social_media_search`   |

***

## `search_and_answer`

Answer a question using web research. Optionally generates subqueries for comprehensive coverage, handles token limits, and synthesizes an answer with your chosen model.

### Parameters

| Parameter                  | Type         | Default   | Description                               |
| -------------------------- | ------------ | --------- | ----------------------------------------- |
| `query`                    | str          | Required  | The question to answer                    |
| `api_key`                  | str          | Required  | Tavily API key                            |
| `model_config`             | ModelConfig  | None      | LLM configuration for synthesis           |
| `max_number_of_subqueries` | int          | 2-4       | Number of subqueries to generate          |
| `output_schema`            | OutputSchema | None      | Pydantic model for structured output      |
| `token_limit`              | int          | 50000     | Maximum token budget for context          |
| `threshold`                | float        | 0.3       | Minimum relevance score                   |
| `topic`                    | str          | "general" | `"general"`, `"news"`, or `"finance"`     |
| `time_range`               | str          | None      | `"day"`, `"week"`, `"month"`, or `"year"` |
| `include_domains`          | list         | None      | Only search these domains                 |
| `exclude_domains`          | list         | None      | Exclude these domains                     |

### Example

```python theme={null}
from tavily_agent_toolkit import search_and_answer, ModelConfig, ModelObject

result = await search_and_answer(
    query="What are the pros and cons of Rust vs Go?",
    api_key="tvly-xxx",
    model_config=ModelConfig(model=ModelObject(model="anthropic:claude-sonnet-4-5")),
    max_number_of_subqueries=3,
)
print(result["answer"])
```

***

## `search_dedup`

Run multiple search queries in parallel and consolidate results. Deduplicates by URL and merges content chunks from the same source.

### Parameters

| Parameter           | Type       | Default    | Description                               |
| ------------------- | ---------- | ---------- | ----------------------------------------- |
| `queries`           | list\[str] | Required   | List of search queries                    |
| `api_key`           | str        | Required   | Tavily API key                            |
| `search_depth`      | str        | "advanced" | `"basic"` or `"advanced"`                 |
| `topic`             | str        | "general"  | `"general"`, `"news"`, or `"finance"`     |
| `max_results`       | int        | 5          | Results per query                         |
| `chunks_per_source` | int        | 3          | Content chunks per source                 |
| `time_range`        | str        | None       | `"day"`, `"week"`, `"month"`, or `"year"` |
| `include_domains`   | list       | None       | Only search these domains                 |
| `exclude_domains`   | list       | None       | Exclude these domains                     |

### Example

```python theme={null}
from tavily_agent_toolkit import search_dedup

results = await search_dedup(
    api_key="tvly-xxx",
    queries=[
        "transformer architecture explained",
        "attention mechanism neural networks",
        "BERT GPT comparison",
    ],
    search_depth="advanced",
    max_results=5,
)

for r in results["results"]:
    print(f"{r['title']}: {r['score']}")
```

***

## `crawl_and_summarize`

Crawl an entire website and summarize the content with your chosen model. Useful for documentation sites, knowledge bases, or product catalogs.

### Parameters

| Parameter       | Type         | Default  | Description                                   |
| --------------- | ------------ | -------- | --------------------------------------------- |
| `url`           | str          | Required | Website URL to crawl                          |
| `model_config`  | ModelConfig  | Required | LLM for summarization                         |
| `api_key`       | str          | Required | Tavily API key                                |
| `instructions`  | str          | None     | Specific extraction instructions              |
| `output_schema` | OutputSchema | None     | Pydantic model for structured output          |
| `max_depth`     | int          | 1-5      | How deep to crawl from starting URL           |
| `max_breadth`   | int          | 20       | Max pages to crawl per level                  |
| `limit`         | int          | 50       | Total max pages to crawl                      |
| `select_paths`  | list         | None     | Only crawl URLs matching these regex patterns |
| `exclude_paths` | list         | None     | Skip URLs matching these regex patterns       |

### Example

```python theme={null}
from tavily_agent_toolkit import crawl_and_summarize, ModelConfig, ModelObject

result = await crawl_and_summarize(
    url="https://docs.example.com",
    model_config=ModelConfig(model=ModelObject(model="anthropic:claude-sonnet-4-20250514")),
    instructions="Extract all API endpoints and their parameters",
    api_key="tvly-xxx",
    max_depth=2,
    select_paths=["/docs/.*", "/api/.*"],
)
print(result["summary"])
```

***

## `extract_and_summarize`

Extract content from specific URLs and summarize with your model. Use when you already know which pages have the information.

### Parameters

| Parameter           | Type         | Default  | Description                                |
| ------------------- | ------------ | -------- | ------------------------------------------ |
| `urls`              | list\[str]   | Required | URLs to extract (max 20)                   |
| `model_config`      | ModelConfig  | Required | LLM for summarization                      |
| `api_key`           | str          | Required | Tavily API key                             |
| `query`             | str          | None     | Focuses extraction on specific information |
| `output_schema`     | OutputSchema | None     | Pydantic model for structured output       |
| `chunks_per_source` | int          | 5        | Content chunks per source                  |
| `extract_depth`     | str          | "basic"  | `"basic"` or `"advanced"`                  |

### Example

```python theme={null}
from tavily_agent_toolkit import extract_and_summarize, ModelConfig, ModelObject

result = await extract_and_summarize(
    urls=["https://en.wikipedia.org/wiki/Artificial_intelligence"],
    model_config=ModelConfig(model=ModelObject(model="groq:llama-3.3-70b-versatile")),
    query="What are the main ethical concerns with AI?",
    api_key="tvly-xxx",
    chunks_per_source=5,
)
print(result["results"][0]["summary"])
```

***

## `social_media_search`

Search specific social platforms for discussions and content.

### Parameters

| Parameter             | Type | Default    | Description                                                                               |
| --------------------- | ---- | ---------- | ----------------------------------------------------------------------------------------- |
| `query`               | str  | Required   | Search query                                                                              |
| `api_key`             | str  | Required   | Tavily API key                                                                            |
| `platform`            | str  | "combined" | `"reddit"`, `"x"`, `"linkedin"`, `"tiktok"`, `"instagram"`, `"facebook"`, or `"combined"` |
| `include_raw_content` | bool | False      | Include full post content                                                                 |
| `max_results`         | int  | 5          | Number of results                                                                         |
| `time_range`          | str  | None       | `"day"`, `"week"`, `"month"`, or `"year"`                                                 |

### Example

```python theme={null}
from tavily_agent_toolkit import social_media_search

results = social_media_search(
    query="best practices for LLM fine-tuning",
    api_key="tvly-xxx",
    platform="reddit",
    max_results=10,
    time_range="month",
)
```

***

## Model Configuration

All tools that use an LLM accept a `ModelConfig`. Use the `"provider:model"` format, and optionally specify fallback models:

```python theme={null}
from tavily_agent_toolkit import ModelConfig, ModelObject

config = ModelConfig(
    model=ModelObject(model="openai:gpt-5.2"),
    fallback_models=[
        ModelObject(model="anthropic:claude-sonnet-4-20250514"),
        ModelObject(model="groq:llama-3.3-70b-versatile"),
    ],
    temperature=0.7,
)
```

**Retry behavior:**

* With `fallback_models`: each model gets 1 attempt before moving to the next
* Without `fallback_models`: primary model gets 1 retry (2 attempts total)

See the [GitHub README](https://github.com/tavily-ai/tavily-cookbook/tree/main/agent-toolkit#model-configuration) for the full list of 20+ supported providers.


# Examples Hub
Source: https://docs.tavily.com/examples/hub

Build with Tavily — from quick API recipes to production research agents.

## Choose by Goal

<CardGroup>
  <Card title="Search the web" icon="magnifying-glass" href="/examples/quick-tutorials/search-api">
    Find and aggregate real-time information from across the web with Tavily Search.
  </Card>

  <Card title="Extract content from URLs" icon="file-lines" href="/examples/quick-tutorials/extract-api">
    Pull clean, structured content from any webpage for downstream processing.
  </Card>

  <Card title="Discover site structure" icon="sitemap" href="/examples/quick-tutorials/map-api">
    Map all URLs on a domain without extracting content — fast site discovery.
  </Card>

  <Card title="Crawl a website" icon="spider-web" href="/examples/quick-tutorials/crawl-api">
    Traverse entire sites and turn them into searchable knowledge bases.
  </Card>

  <Card title="Run deep research" icon="flask-vial" href="/examples/quick-tutorials/research-streaming">
    Submit multi-source research queries with streaming progress and structured output.
  </Card>

  <Card title="Build a research agent" icon="robot" href="/examples/agent-toolkit/overview">
    Production-grade agent patterns with the Tavily Agent Toolkit.
  </Card>
</CardGroup>

***

## Choose by Stack

<CardGroup>
  <Card title="Python SDK" icon="python" href="/sdk/python/quick-start">
    Search, Extract, Crawl, Map
  </Card>

  <Card title="Agent Toolkit" icon="toolbox" href="/examples/agent-toolkit/overview">
    Tools, agents, and use-case recipes
  </Card>

  <Card title="MCP Server" icon="server" href="/documentation/mcp">
    Cursor, Claude Desktop, Claude Code
  </Card>

  <Card title="CLI" icon="terminal" href="/documentation/tavily-cli">
    Search, extract, crawl from your terminal
  </Card>

  <Card title="Integrations" icon="link-horizontal" href="/documentation/integrations">
    LangChain, Vercel AI SDK, n8n, and more
  </Card>

  <Card title="REST API" icon="code" href="/documentation/api-reference/introduction">
    Direct HTTP endpoints
  </Card>
</CardGroup>

***

## Featured

<CardGroup>
  <Card title="Chatbot Agent" icon="message-bot" href="/examples/agent-toolkit/chatbot">
    Routes between quick search and deep research based on query complexity.
  </Card>

  <Card title="Hybrid Research" icon="flask" href="/examples/agent-toolkit/hybrid-research">
    Combine internal data with web research for comprehensive reports.
  </Card>

  <Card title="Crawl to RAG" icon="database" href="/examples/use-cases/crawl-to-rag">
    Turn any website into a searchable knowledge base with MongoDB Atlas.
  </Card>
</CardGroup>

***

## Browse All

<CardGroup>
  <Card title="Agent Toolkit" icon="toolbox" href="/examples/agent-toolkit/overview">
    Pre-built tools, agents, and use-case recipes for production research systems.
  </Card>

  <Card title="Demo Apps" icon="window-maximize" href="/examples/use-cases/chat">
    Open-source apps you can try live and deploy: chat, research, data enrichment, and more.
  </Card>

  <Card title="Cookbook" icon="book-open" href="/examples/quick-tutorials/cookbook">
    Guided Jupyter notebooks covering every Tavily API from fundamentals to advanced patterns.
  </Card>

  <Card title="Open Source" icon="code-branch" href="/examples/open-sources/projects">
    Community projects built with Tavily.
  </Card>
</CardGroup>


# Projects
Source: https://docs.tavily.com/examples/open-sources/projects

Explore our collection of popular open source projects that showcase Tavily's use cases and capabilities.

<Visibility>
  ## Open source projects using Tavily

  * [assafelovic/gpt-researcher](https://github.com/assafelovic/gpt-researcher)
  * [kortix-ai/suna](https://github.com/kortix-ai/suna)
  * [bytedance/deer-flow](https://github.com/bytedance/deer-flow)
  * [langchain-ai/open\_deep\_research](https://github.com/langchain-ai/open_deep_research)
  * [miurla/morphic](https://github.com/miurla/morphic)
  * [meta-llama/llama-stack-apps](https://github.com/meta-llama/llama-stack-apps)
  * [rotemweiss57/gpt-newspaper](https://github.com/rotemweiss57/gpt-newspaper)
  * [Darwin-lfl/langmanus](https://github.com/Darwin-lfl/langmanus)
  * [aws-samples/bedrock-engineer](https://github.com/aws-samples/bedrock-engineer)
  * [togethercomputer/open\_deep\_research](https://github.com/togethercomputer/open_deep_research)
  * [CopilotKit/open-research-ANA](https://github.com/CopilotKit/open-research-ANA)
  * [aws-samples/sample-bedrock-deep-researcher](https://github.com/aws-samples/sample-bedrock-deep-researcher)
  * [NVIDIA-AI-Blueprints/biomedical-aiq-research-agent](https://github.com/NVIDIA-AI-Blueprints/biomedical-aiq-research-agent)
</Visibility>

<GitHubReposGrid />


# Cookbook
Source: https://docs.tavily.com/examples/quick-tutorials/cookbook

Guided Jupyter notebooks covering Tavily's APIs — from fundamentals to advanced research patterns, crawling pipelines, and framework integrations.

Hands-on notebooks you can run locally or on [Colab](https://colab.research.google.com/). Each notebook focuses on a single concept with detailed code and explained outputs.

<Card title="View all notebooks on GitHub" icon="github" href="https://github.com/tavily-ai/tavily-cookbook/tree/main/cookbooks" />

## Getting Started

<CardGroup>
  <Card href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/getting-started/search-extract-crawl.ipynb" title="Search, Extract & Crawl">
    Core API walkthrough — learn the three foundational endpoints with guided examples.
  </Card>

  <Card href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/getting-started/web-agent-tutorial.ipynb" title="Web Agent">
    Build an LLM-powered web research agent that uses Tavily tools end-to-end.
  </Card>

  <Card href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/getting-started/hybrid-agent-tutorial.ipynb" title="Hybrid Agent">
    Combine a Chroma vector store with Tavily web search for hybrid answers.
  </Card>
</CardGroup>

## Search

<CardGroup>
  <Card href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/search/product_news_tracker.ipynb" title="Product News Tracker">
    Track product updates using domain-filtered and news-specific search parameters.
  </Card>
</CardGroup>

## Research

<CardGroup>
  <Card href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/research/polling.ipynb" title="Polling">
    Submit async research jobs and poll for completion — ideal for background processing.
  </Card>

  <Card href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/research/streaming.ipynb" title="Streaming">
    Stream real-time progress events and answers during research execution.
  </Card>

  <Card href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/research/structured_output.ipynb" title="Structured Output">
    Get research results in custom JSON schemas with Pydantic-style definitions.
  </Card>

  <Card href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/research/query_refinement.ipynb" title="Query Refinement">
    Multi-turn clarification flow that refines user prompts before running research.
  </Card>

  <Card href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/research/hybrid_research.ipynb" title="Hybrid Research">
    Combine Tavily research with your internal data for comprehensive reports.
  </Card>
</CardGroup>

## Crawl

<CardGroup>
  <Card href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/crawl/getting_started.ipynb" title="Crawl Fundamentals">
    Crawl and map basics — depth, breadth, and path controls with visualization.
  </Card>

  <Card href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/crawl/crawl_to_rag.ipynb" title="Crawl to RAG">
    Full pipeline from website crawl to chunked embeddings to Q\&A with a vector store.
  </Card>

  <Card href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/crawl/agent_grounding.ipynb" title="Agent Grounding">
    LangGraph-style research agent that uses search, map, and extract for autonomous web research.
  </Card>

  <Card href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/crawl/data_collection.ipynb" title="Data Collection">
    Crawl websites and export pages as organized PDF files for offline analysis.
  </Card>
</CardGroup>

## Integrations

<CardGroup>
  <Card href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/integrations/langchain/langchain.ipynb" title="LangChain">
    LangChain tool wrappers for Search, Extract, Map, and Crawl with filtered and news variants.
  </Card>

  <Card href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/mcp/remote-mcp.ipynb" title="Remote MCP">
    Configure Tavily's remote MCP server and call it from an OpenAI client.
  </Card>

  <Card href="https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/integrations/aws-strands/deep-research.ipynb" title="AWS Strands">
    Deep research agent using AWS Strands with Bedrock and Tavily search, extract, and crawl tools.
  </Card>
</CardGroup>


# Website Crawling and Content Extraction
Source: https://docs.tavily.com/examples/quick-tutorials/crawl-api

Use Tavily Crawl to extract content from entire websites — documentation ingestion, selective path crawling, and building retrieval pipelines.

## What You'll Learn

* Crawling a website and extracting clean content from its pages
* Using path filters and instructions for selective crawling
* When to use Crawl vs Map
* Feeding crawled content into a retrieval pipeline

## How Does It Work?

Tavily Crawl follows links from a starting URL and extracts clean content from each page it visits. Unlike Map (which only discovers URLs), Crawl returns the full page content as markdown or text, ready for LLM consumption.

| Feature      | Crawl                                          | Map                                               |
| ------------ | ---------------------------------------------- | ------------------------------------------------- |
| **Returns**  | URLs + full page content                       | URL list only                                     |
| **Speed**    | Slower (extracts content)                      | Fast (seconds)                                    |
| **Cost**     | Higher (extraction per page)                   | Lower                                             |
| **Best for** | RAG pipelines, content analysis, documentation | Site discovery, URL filtering, sitemap generation |

**Rule of thumb**: Use Map when you need to *find* pages. Use Crawl when you need to *read* pages.

## Getting Started

<Card title="Get your Tavily API key" icon="key" href="https://app.tavily.com" />

<Steps>
  <Step title="Install the Tavily Python SDK">
    ```bash theme={null}
    uv venv
    uv pip install tavily-python
    ```
  </Step>

  <Step title="Crawl a website">
    ```python theme={null}
    import os
    from tavily import TavilyClient

    client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

    response = client.crawl(
        url="https://docs.tavily.com",
        max_depth=1,
        limit=10,
    )

    for page in response["results"]:
        print(f"\n--- {page['url']} ---")
        print(f"Content length: {len(page['raw_content'])} chars")
        print(page["raw_content"][:200])
    ```
  </Step>

  <Step title="Output">
    ```text theme={null}
    --- https://docs.tavily.com/ ---
    Content length: 4040 chars
    # Tavily docs

    Search, crawl, and extract content from the web with APIs
    built for LLMs and autonomous agents...

    --- https://docs.tavily.com/documentation/api-reference/introduction ---
    Content length: 3647 chars
    # API Reference Introduction

    This section covers Tavily endpoint APIs, request parameters,
    and response schemas...
    ```
  </Step>
</Steps>

## Documentation Ingestion

Crawl a docs site with `select_paths` to focus on the pages that matter, and `extract_depth: "advanced"` for complex pages with tables or code blocks.

```python theme={null}
import os
from tavily import TavilyClient

client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

response = client.crawl(
    url="https://docs.tavily.com",
    max_depth=2,
    limit=50,
    select_paths=["/documentation/.*", "/sdk/.*"],
    exclude_paths=["/changelog/.*"],
    extract_depth="advanced",
)

pages = response["results"]
print(f"Crawled {len(pages)} pages")

for page in pages:
    print(f"  {page['url']} ({len(page['raw_content'])} chars)")
```

<Tip>
  Start with `max_depth=1` and a conservative `limit`. Each level of depth increases crawl time exponentially — scale up only after verifying results.
</Tip>

## Selective Path Crawling

Combine path patterns with natural-language `instructions` to focus the crawl semantically. When `instructions` are set, you can also use `chunks_per_source` to get only the most relevant snippets per page.

```python theme={null}
import os
from tavily import TavilyClient

client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

response = client.crawl(
    url="https://docs.tavily.com",
    max_depth=2,
    select_paths=["/documentation/api-reference/.*"],
    exclude_paths=["/documentation/api-reference/endpoint/research-streaming"],
    instructions="Find pages about Search and Extract endpoints",
    chunks_per_source=3,
)

for page in response["results"]:
    print(f"\n{page['url']}")
    print(page["raw_content"])
```

With `chunks_per_source`, the `raw_content` field contains the top relevant chunks separated by `[...]` instead of the full page, keeping context windows small.

## Crawl-to-Retrieval Pipeline

Crawl a site, chunk the content, and build a searchable index. This sketch shows the pattern — for a complete implementation, see the [Crawl to RAG](/examples/use-cases/crawl-to-rag) app example.

```python theme={null}
import os
from tavily import TavilyClient

client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

def chunk_text(text, chunk_size=500, overlap=50):
    """Split text into overlapping chunks."""
    chunks = []
    start = 0
    while start < len(text):
        end = start + chunk_size
        chunks.append(text[start:end])
        start = end - overlap
    return chunks

response = client.crawl(
    url="https://docs.tavily.com",
    max_depth=2,
    limit=30,
    extract_depth="advanced",
)

all_chunks = []
for page in response["results"]:
    chunks = chunk_text(page["raw_content"])
    for chunk in chunks:
        all_chunks.append({
            "text": chunk,
            "url": page["url"],
        })

print(f"Created {len(all_chunks)} chunks from {len(response['results'])} pages")

# Next steps: embed chunks and load into a vector store
# See the Crawl to RAG example for the full pipeline
```

## Critical Knobs

<AccordionGroup>
  <Accordion title="max_depth">
    * **Range:** 1–5, **default:** 1
    * Each level increases crawl time exponentially
    * Start at 1 and increase only after verifying results
  </Accordion>

  <Accordion title="max_breadth">
    * **Range:** 1–500, **default:** 20
    * Controls how many links are followed per page level
  </Accordion>

  <Accordion title="limit">
    * Hard cap on total pages crawled
    * Always set this to prevent runaway crawls and unexpected costs
  </Accordion>

  <Accordion title="select_paths / exclude_paths">
    * Regex patterns to include or exclude URL paths
    * Example: `"/docs/.*"` to target docs, `"/blog/.*"` to skip blog posts
  </Accordion>

  <Accordion title="extract_depth">
    * `"basic"` (default) — standard content, faster
    * `"advanced"` — tables, embedded content, JS-rendered pages, slower but more thorough
  </Accordion>

  <Accordion title="instructions">
    * Natural-language guidance for the crawler
    * Enables semantic filtering of pages
    * Unlocks `chunks_per_source` for targeted content retrieval
  </Accordion>
</AccordionGroup>

For the complete parameter list, see the [Crawl API reference](/documentation/api-reference/endpoint/crawl).

## Production Notes

* **Cost control**: Always set `limit` to cap the number of pages. Each crawled page consumes credits based on `extract_depth`.
* **Timeouts**: Large crawls can take time. Use the `timeout` parameter (10-150s) to set upper bounds.
* **Failed pages**: Check `response["failed_results"]` for pages that couldn't be extracted. Adjust `extract_depth` or path filters accordingly.
* **Map first**: Consider using [Map](/examples/quick-tutorials/map-api) to discover the site structure before crawling. This lets you identify the right `select_paths` patterns and set a realistic `limit`.

## Next Steps

<CardGroup>
  <Card title="Crawl API Reference" icon="code" href="/documentation/api-reference/endpoint/crawl">
    Full parameter list, response schema, and interactive playground.
  </Card>

  <Card title="Crawl Best Practices" icon="gear" href="/documentation/best-practices/best-practices-crawl">
    Depth tuning, path filtering, domain controls, and common pitfalls.
  </Card>

  <Card title="Python SDK Reference" icon="python" href="/sdk/python/reference">
    Python client methods, async support, and type details.
  </Card>

  <Card title="JavaScript SDK Reference" icon="js" href="/sdk/javascript/reference">
    JavaScript/TypeScript client methods and usage.
  </Card>
</CardGroup>


# Clean Content Extraction
Source: https://docs.tavily.com/examples/quick-tutorials/extract-api

Use Tavily Extract to pull clean markdown or text from any webpage — single URLs, batches, or query-focused chunks.

## What You'll Learn

* Extracting clean content from one or many URLs
* Basic vs advanced extraction depth
* Query-focused extraction for targeted content retrieval
* Batch extraction (up to 20 URLs in a single call)

## How Does It Work?

Tavily Extract takes a URL (or list of URLs) and returns the page content as clean markdown or plain text. It handles JavaScript-rendered pages, removes boilerplate (ads, navigation, footers), and returns structured content ready for LLM consumption.

Two extraction depths are available:

| Depth      | Speed  | Success Rate | Content                                     | Cost                 |
| ---------- | ------ | ------------ | ------------------------------------------- | -------------------- |
| `basic`    | Fast   | Good         | Standard page content                       | 1 credit per 5 URLs  |
| `advanced` | Slower | Higher       | Tables, embedded content, JS-rendered pages | 2 credits per 5 URLs |

## Getting Started

<Card title="Get your Tavily API key" icon="key" href="https://app.tavily.com" />

<Steps>
  <Step title="Install the Tavily Python SDK">
    ```bash theme={null}
    uv venv
    uv pip install tavily-python
    ```
  </Step>

  <Step title="Extract content from a URL">
    ```python theme={null}
    import os
    from tavily import TavilyClient

    client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

    response = client.extract(
        urls="https://en.wikipedia.org/wiki/Artificial_intelligence",
        extract_depth="advanced",
    )

    result = response["results"][0]
    print(f"URL: {result['url']}")
    print(f"Content length: {len(result['raw_content'])} chars")
    print(result["raw_content"][:500])
    ```
  </Step>

  <Step title="Output">
    ```text theme={null}
    URL: https://en.wikipedia.org/wiki/Artificial_intelligence
    Content length: 48231 chars
    # Artificial intelligence

    **Artificial intelligence (AI)**, in its broadest sense,
    is intelligence exhibited by machines, particularly
    computer systems. It is a field of research in computer
    science that develops and studies methods and software
    that enable machines to perceive their environment and
    use learning and intelligence to take actions...
    ```
  </Step>
</Steps>

## Batch Extraction

Extract content from up to 20 URLs in a single call. Failed URLs are reported separately without blocking successful ones.

```python theme={null}
import os
from tavily import TavilyClient

client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

urls = [
    "https://en.wikipedia.org/wiki/Artificial_intelligence",
    "https://en.wikipedia.org/wiki/Machine_learning",
    "https://en.wikipedia.org/wiki/Data_science",
]

response = client.extract(urls=urls, include_images=True)

for result in response["results"]:
    print(f"{result['url']}: {len(result['raw_content'])} chars")

if response["failed_results"]:
    for fail in response["failed_results"]:
        print(f"Failed: {fail['url']} - {fail['error']}")
```

## Query-Focused Extraction

When you pass a `query` parameter, Extract reranks the content chunks by relevance to your question. Combined with `chunks_per_source`, this returns only the most relevant portions of each page.

```python theme={null}
import os
from tavily import TavilyClient

client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

response = client.extract(
    urls="https://en.wikipedia.org/wiki/Artificial_intelligence",
    query="What are the main ethical concerns with AI?",
    chunks_per_source=3,
)

print(response["results"][0]["raw_content"])
```

The `raw_content` field will contain the top 3 most relevant chunks separated by `[...]`, rather than the full page content. This is useful for keeping LLM context windows small while maintaining relevance.

## Choosing the Right Extraction Depth

<AccordionGroup>
  <Accordion title="When to use basic extraction">
    * Static HTML pages (blogs, articles, documentation)
    * When speed matters more than completeness
    * High-volume batch jobs where cost is a concern
    * Pages with straightforward content structure
  </Accordion>

  <Accordion title="When to use advanced extraction">
    * JavaScript-rendered single-page applications
    * Pages with tables, charts, or embedded content
    * When you need the highest success rate
    * Complex pages where basic extraction misses content
  </Accordion>
</AccordionGroup>

## Critical Knobs

<AccordionGroup>
  <Accordion title="extract_depth">
    * `"basic"` (default) — standard HTML pages, 1 credit per 5 URLs
    * `"advanced"` — JS-rendered pages, tables, embedded content, 2 credits per 5 URLs
  </Accordion>

  <Accordion title="query + chunks_per_source">
    * Pass a `query` to rerank content by relevance to your question
    * Pair with `chunks_per_source` (1–5) to return only the top snippets
    * Without `query`, full page content is returned
  </Accordion>

  <Accordion title="format">
    * `"markdown"` (default) — preserves headings, links, and structure
    * `"text"` — plain text, lighter for simple pipelines
  </Accordion>
</AccordionGroup>

For the complete parameter list, see the [Extract API reference](/documentation/api-reference/endpoint/extract).

## Next Steps

<CardGroup>
  <Card title="Extract API Reference" icon="code" href="/documentation/api-reference/endpoint/extract">
    Full parameter list, response schema, and interactive playground.
  </Card>

  <Card title="Extract Best Practices" icon="gear" href="/documentation/best-practices/best-practices-extract">
    Depth selection, two-step search-then-extract, and optimization tips.
  </Card>

  <Card title="Python SDK Reference" icon="python" href="/sdk/python/reference">
    Python client methods, async support, and type details.
  </Card>

  <Card title="JavaScript SDK Reference" icon="js" href="/sdk/javascript/reference">
    JavaScript/TypeScript client methods and usage.
  </Card>
</CardGroup>


# Site Structure Discovery with Map
Source: https://docs.tavily.com/examples/quick-tutorials/map-api

Use Tavily Map to discover all URLs on a domain, then combine with Extract for targeted content retrieval.

## What You'll Learn

* How to use Tavily Map to discover all URLs on a domain without extracting content
* When to use Map vs Crawl (speed vs depth)
* How to combine Map + Extract for targeted content retrieval
* Filtering results with path and domain patterns

## How Does It Work?

Tavily Map returns a list of URLs discovered from a starting URL. Unlike Crawl, it does not extract page content -- it only discovers the structure. This makes it significantly faster and cheaper when you need to understand what's on a site before deciding which pages to process.

| Feature  | Map                           | Crawl                             |
| -------- | ----------------------------- | --------------------------------- |
| Returns  | URL list only                 | URLs + full page content          |
| Speed    | Fast (seconds)                | Slower (depends on page count)    |
| Cost     | Lower                         | Higher                            |
| Best for | Site discovery, URL filtering | Content extraction, RAG pipelines |

## Getting Started

<Card title="Get your Tavily API key" icon="key" href="https://app.tavily.com" />

<Steps>
  <Step title="Install the Tavily Python SDK">
    ```bash theme={null}
    uv venv
    uv pip install tavily-python
    ```
  </Step>

  <Step title="Set up your client">
    ```python theme={null}
    import os
    from tavily import TavilyClient

    client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
    ```
  </Step>

  <Step title="Map a website">
    ```python theme={null}
    import os
    from tavily import TavilyClient

    client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

    response = client.map(url="https://docs.tavily.com")

    print(f"Found {len(response['results'])} URLs")
    for url in response["results"][:10]:
        print(url)
    ```
  </Step>

  <Step title="Output">
    ```python theme={null}
    Found 21 URLs
    https://docs.tavily.com/
    https://docs.tavily.com/changelog
    https://docs.tavily.com/welcome
    https://docs.tavily.com/documentation/api-credits
    https://docs.tavily.com/documentation/help
    ...
    ```
  </Step>
</Steps>

## Filtering with Path Patterns

Use `select_paths` and `exclude_paths` to focus the map on specific sections of a site. These accept regex patterns.

```python theme={null}
import os
from tavily import TavilyClient

client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

response = client.map(
    url="https://docs.tavily.com",
    select_paths=["/documentation/api-reference/.*", "/sdk/.*"],
    exclude_paths=["/changelog/.*"],
    max_depth=2,
    allow_external=False,
)
```

You can also use `instructions` for natural language guidance:

```python theme={null}
import os
from tavily import TavilyClient

client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

response = client.map(
    url="https://docs.tavily.com",
    instructions="Find pages related to the Python SDK",
    allow_external=False,
)
```

## Map + Extract: Targeted Content Retrieval

The real power of Map is combining it with Extract. First discover the site structure, then extract only the pages you care about.

```python theme={null}
import os
from tavily import TavilyClient

client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

map_response = client.map(
    url="https://docs.tavily.com",
    select_paths=["/documentation/api-reference/endpoint/.*"],
    max_depth=2,
    allow_external=False,
)

api_urls = map_response["results"][:5]

extract_response = client.extract(
    urls=api_urls,
    extract_depth="advanced",
)

for result in extract_response["results"]:
    print(f"\n--- {result['url']} ---")
    print(result["raw_content"][:300])
```

This two-step approach lets you process only relevant pages instead of crawling an entire site.

## Critical Knobs

<AccordionGroup>
  <Accordion title="max_depth">
    * **Default:** 1
    * Higher values discover more pages but take longer
  </Accordion>

  <Accordion title="limit">
    * **Default:** 50
    * Total URL cap before stopping
  </Accordion>

  <Accordion title="select_paths / exclude_paths">
    * Regex patterns to include or exclude URL paths
    * Example: `"/docs/.*"` to target docs, `"/blog/.*"` to skip blog posts
  </Accordion>

  <Accordion title="instructions">
    * Natural-language guidance for the mapper
    * Use when regex patterns aren't enough and you need semantic filtering
    * Example: `"Find pages related to the Python SDK"`
  </Accordion>
</AccordionGroup>

For the complete parameter list, see the [Map API reference](/documentation/api-reference/endpoint/map).

## Next Steps

<CardGroup>
  <Card title="Map API Reference" icon="code" href="/documentation/api-reference/endpoint/map">
    Full parameter list, response schema, and interactive playground.
  </Card>

  <Card title="Extract API Tutorial" icon="file-lines" href="/examples/quick-tutorials/extract-api">
    Learn Extract in depth: batch processing, query-focused extraction, and more.
  </Card>

  <Card title="Python SDK Reference" icon="python" href="/sdk/python/reference">
    Python client methods, async support, and type details.
  </Card>

  <Card title="JavaScript SDK Reference" icon="js" href="/sdk/javascript/reference">
    JavaScript/TypeScript client methods and usage.
  </Card>
</CardGroup>


# Product News Tracker
Source: https://docs.tavily.com/examples/quick-tutorials/product-news-tracker

Stay informed with real-time product news using Tavily's APIs.

## What will you learn?

In this use case, you'll discover how to gather a company's product news and updates using Tavily's Search API. This tutorial outlines how to get started with the Tavily Python SDK, how to properly configure search parameters for optimal results, and how to effectively interact with Tavily’s Search API to retrieve the latest product updates for a specified company.

## How does it work?

### Self-Reported News

Our system gathers official updates including **blog posts**, **product announcements**, and **company news** by utilizing the `include_domain` parameter. This allows us to focus specifically on content from:

* A company's official website

This domain-filtered approach ensures efficient credit usage while maintaining search accuracy.

### Third-Party Coverage

To capture external perspectives, we employ specialized news search parameters:

* Set `topic = news` to focus on reputable news sources
* Utilize `time_range = month` for current coverage

<Tip>
  For the functionality discussed in this tutorial, `search_depth = basic` will
  be sufficient to achieve the intended results.
</Tip>

## Getting Started

> We have prepared a [Jupyter Notebook](https://github.com/tavily-ai/tavily-cookbook/blob/main/cookbooks/search/product_news_tracker.ipynb) outlining the contents of this tutorial

First create an account and get your free API key.

<Card title="Get your Tavily API key" icon="key" href="https://app.tavily.com" />

Next, use the Tavily Python SDK to create the workflow.

<Steps>
  <Step title="Install the Tavily Python SDK">
    ```bash Shell theme={null}
    uv venv
    uv pip install tavily-python python-dotenv ipykernel
    ```
  </Step>

  <Step title="Import the necessary libraries">
    ```python Python theme={null}
    import getpass
    import os

    if not os.environ.get("TAVILY_API_KEY"):
        os.environ["TAVILY_API_KEY"] = getpass.getpass("TAVILY_API_KEY:\n")

    TAVILY_API_KEY = os.getenv("TAVILY_API_KEY")
    ```
  </Step>

  <Step title="Instantiate the Tavily Client">
    ```python Python theme={null}
    from tavily import TavilyClient

    tavily_client = TavilyClient()
    ```
  </Step>

  <Step title="Define the search parameters">
    ```python Python theme={null}
    def search_product_updates(company_name: str, domains: list):
        all_results = []

        # Search for self-reported news
        company_results = tavily_client.search(
            query=f"{company_name} product news, updates, releases, and announcements",
            search_depth="basic",
            max_results=10,
            include_domains=domains
        )

        for result in company_results["results"]:
            result["search_type"] = "Self-reported News"
            all_results.append(result)


        # Search for third-party coverage
        news_results = tavily_client.search(
            query=f"{company_name} product news, updates, releases, and announcements",
            search_depth="basic",
            max_results=10,
            time_range="month",
            topic="news"
        )

        for result in news_results["results"]:
            result["search_type"] = "Third-party Coverage"
            all_results.append(result)

        return all_results
    ```
  </Step>

  <Step title="Execute the search">
    ```python Python theme={null}
        product_updates = search_product_updates(
            "OpenAI", ["openai.com"]
        )

        print(product_updates)
    ```
  </Step>

  <Step title="Output">
    ```json Shell theme={null}
     [
         {
             "title": "OpenAI launches new tools to help businesses build AI agents - TechCrunch",
             "url": "https://techcrunch.com/2025/03/11/openai-launches-new-tools-to-help-businesses-build-ai-agents/",
             "score": 0.70847535,
             "published_date": "Tue, 11 Mar 2025 17:00:00 GMT",
             "content": "OpenAI launches new tools to help businesses build AI agents | TechCrunch OpenAI launches new tools to help businesses build AI agents | TechCrunch On Tuesday, OpenAI released new tools designed to help developers and enterprises build AI agents – automated systems that can independently accomplish tasks – using the company’s own AI models and frameworks. The tools are part of OpenAI’s new Responses API, which lets businesses develop custom AI agents that can perform web searches, scan through company files, and navigate websites, much like OpenAI’s Operator product. Using the Responses API, developers can tap the same AI models (in preview) under the hood of OpenAI’s ChatGPT Search web search tool: GPT-4o search and GPT-4o mini search.",
             "search_type": "Third-party Coverage"
         },
         {
             "title": "New embedding models and API updates - Announcements - OpenAI Developer ...",
             "url": "https://community.openai.com/t/new-embedding-models-and-api-updates/610540",
             "score": 0.752468,
             "content": "We are releasing new models, reducing prices for GPT-3.5 Turbo, and introducing new ways for developers to manage API keys and understand API usage. The new models include: Two new embedding models An updated GPT-4 Turbo preview model An updated GPT-3.5 Turbo model An updated text moderation model By default, data sent to the OpenAI API will not be used to train or improve OpenAI models. All",
             "search_type": "Self-reported News"
         },
         ...
     ]
    ```
  </Step>
</Steps>


# Deep Research with Streaming
Source: https://docs.tavily.com/examples/quick-tutorials/research-streaming

Submit multi-source research queries with polling or streaming, and get structured output with custom schemas.

## What You'll Learn

* Submitting a research request and polling for results
* Streaming research progress in real time
* Handling streaming events (progress updates, source discoveries, content generation)
* Getting structured output with custom schemas

## How Does It Work?

Tavily Research is a multi-agent deep research endpoint. You submit a query, and Tavily's research agents autonomously search, extract, and synthesize information from multiple sources into a comprehensive report. Two consumption patterns are available:

| Pattern       | Best For                    | How It Works                           |
| ------------- | --------------------------- | -------------------------------------- |
| **Polling**   | Background jobs, serverless | Submit request, poll for completion    |
| **Streaming** | Real-time UIs, CLI tools    | Receive progress events as they happen |

## Getting Started

<Card title="Get your Tavily API key" icon="key" href="https://app.tavily.com" />

```bash theme={null}
uv venv
uv pip install tavily-python
# Optional (used in the production helper example below)
uv pip install tavily-agent-toolkit
```

## Polling

`client.research()` returns immediately with a pending task. Use `client.get_research()` to poll until the status is `"completed"`.

```python theme={null}
import os
import time
from tavily import TavilyClient

client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

task = client.research(
    input="What are the key trends in AI agents for 2026?",
    model="mini",
)

print(f"Task created: {task['request_id']} (status: {task['status']})")

while True:
    result = client.get_research(task["request_id"])

    if result["status"] == "completed":
        break
    elif result["status"] == "failed":
        raise RuntimeError("Research task failed")

    print(f"Status: {result['status']}...")
    time.sleep(5)

print(result["content"])
print(f"\nSources: {len(result['sources'])}")
for source in result["sources"]:
    print(f"  - {source['title']}: {source['url']}")
```

## Streaming

Stream research progress in real time. The API sends Server-Sent Events (SSE) in an OpenAI-compatible `chat.completion.chunk` format as the research agents work. You can display tool activity, show discovered sources, and stream the final report as it generates.

```python theme={null}
import json
import os
from tavily import TavilyClient

client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

stream = client.research(
    input="What are the key trends in AI agents for 2026?",
    model="mini",
    stream=True,
)

for chunk in stream:
    text = chunk.decode("utf-8")

    for line in text.splitlines():
        line = line.strip()
        if not line:
            continue

        if line.startswith("event:"):
            event_name = line.split(":", 1)[1].strip()
            if event_name == "done":
                print("\n\n[stream complete]")
            continue

        if not line.startswith("data:"):
            continue

        payload = line.split(":", 1)[1].strip()
        if not payload:
            continue

        data = json.loads(payload)
        delta = data.get("choices", [{}])[0].get("delta", {})

        if "tool_calls" in delta:
            tc = delta["tool_calls"]
            if tc.get("type") == "tool_call":
                for tool in tc.get("tool_call", []):
                    print(f"[{tool.get('name')}] {tool.get('arguments', '')}")
            elif tc.get("type") == "tool_response":
                for tr in tc.get("tool_response", []):
                    for s in tr.get("sources", []):
                        print(f"  Source: {s['title']} — {s['url']}")

        if "content" in delta and isinstance(delta["content"], str):
            print(delta["content"], end="", flush=True)

        if "sources" in delta:
            print("\n\n--- All Sources ---")
            for s in delta["sources"]:
                print(f"  {s['title']}: {s['url']}")
```

### Streaming Event Flow

A typical session progresses through these stages:

| Stage      | Delta field                                       | What happens                                 |
| ---------- | ------------------------------------------------- | -------------------------------------------- |
| Planning   | `tool_calls` (type `tool_call`)                   | Research plan is initialized                 |
| Searching  | `tool_calls` (type `tool_call` / `tool_response`) | Web searches execute, sources are discovered |
| Subtopics  | `tool_calls` (Pro only)                           | `ResearchSubtopic` calls for deeper dives    |
| Generating | `tool_calls`                                      | Final report generation begins               |
| Content    | `content`                                         | Report chunks stream incrementally           |
| Sources    | `sources`                                         | Complete list of all sources used            |
| Done       | SSE `event: done`                                 | Stream complete                              |

For full event structure and field-level details, see the [Streaming API reference](/documentation/api-reference/endpoint/research-streaming).

## Structured Output

Use `output_schema` to get research results in a custom JSON format. Define your schema as a dictionary of field names to descriptions.

```python theme={null}
import os
import json
import time
from tavily import TavilyClient

client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

task = client.research(
    input="Compare React, Vue, and Svelte for building web apps",
    model="mini",
    output_schema={
        "properties": {
            "frameworks": {
                "type": "array",
                "description": "List of frameworks compared",
                "items": {
                    "type": "object",
                    "properties": {
                        "name": {"type": "string", "description": "Framework name"},
                        "strengths": {
                            "type": "array",
                            "description": "Key strengths",
                            "items": {"type": "string"}
                        },
                        "weaknesses": {
                            "type": "array",
                            "description": "Key weaknesses",
                            "items": {"type": "string"}
                        },
                        "best_for": {"type": "string", "description": "Best use case"}
                    },
                    "required": ["name", "best_for"]
                }
            },
            "recommendation": {"type": "string", "description": "Overall recommendation"}
        },
        "required": ["frameworks", "recommendation"]
    },
)

while True:
    result = client.get_research(task["request_id"])
    if result["status"] == "completed":
        break
    if result["status"] == "failed":
        raise RuntimeError("Research task failed")
    time.sleep(5)

content = result["content"]
structured = json.loads(content) if isinstance(content, str) else content

for fw in structured["frameworks"]:
    print(f"\n{fw['name']}: Best for {fw['best_for']}")
```

## Handling Research Streams in Production

For production applications, use the `handle_research_stream` utility from the Agent Toolkit to process streaming events cleanly:

```python theme={null}
import os
from tavily import TavilyClient
from tavily_agent_toolkit import handle_research_stream

client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

response = client.research(
    input="Analysis of the AI search market landscape",
    model="pro",
    stream=True,
)

report = handle_research_stream(
    response,
    stream_content_generation=True,
)

print(report)
```

## Critical Knobs

<AccordionGroup>
  <Accordion title="model">
    * `"auto"` (default) — Tavily picks based on query complexity
    * `"pro"` — comprehensive, multi-agent research for complex topics
    * `"mini"` — faster, targeted research for narrow questions
  </Accordion>

  <Accordion title="stream">
    * `true` — real-time SSE progress events
    * `false` (default) — single response, poll for completion
  </Accordion>

  <Accordion title="output_schema">
    * Pass a JSON Schema object to get structured data instead of a markdown report
    * Write clear field descriptions for best results
  </Accordion>

  <Accordion title="citation_format">
    * `"numbered"` (default), `"mla"`, `"apa"`, `"chicago"`
    * Controls how sources are cited in the report
  </Accordion>
</AccordionGroup>

For the complete parameter list, see the [Research API reference](/documentation/api-reference/endpoint/research).

## Next Steps

<CardGroup>
  <Card title="Research API Reference" icon="code" href="/documentation/api-reference/endpoint/research">
    Full parameter list, response schema, and interactive playground.
  </Card>

  <Card title="Streaming API Reference" icon="bolt" href="/documentation/api-reference/endpoint/research-streaming">
    Complete SSE event structure, field details, and tool types.
  </Card>

  <Card title="Research Best Practices" icon="gear" href="/documentation/best-practices/best-practices-research">
    Prompting tips, model selection, and structured output guidance.
  </Card>

  <Card title="Python SDK Reference" icon="python" href="/sdk/python/reference">
    Python client methods, async support, and type details.
  </Card>
</CardGroup>


# Web Search Essentials
Source: https://docs.tavily.com/examples/quick-tutorials/search-api

Use Tavily Search to find real-time information, monitor news, filter by domain, and aggregate results across multiple queries.

## What You'll Learn

* Running a basic web search and reading results
* Filtering by recency and news sources
* Constraining searches to specific domains
* Aggregating results across multiple queries with async

## How Does It Work?

Tavily Search returns relevant web results for a natural-language query, optimized for LLM consumption. Each result includes a title, URL, relevance score, and a content snippet. You can tune the depth/speed tradeoff, filter by topic or time range, and restrict results to specific domains.

## Getting Started

<Card title="Get your Tavily API key" icon="key" href="https://app.tavily.com" />

<Steps>
  <Step title="Install the Tavily Python SDK">
    ```bash theme={null}
    uv venv
    uv pip install tavily-python
    ```
  </Step>

  <Step title="Run a search">
    ```python theme={null}
    import os
    from tavily import TavilyClient

    client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

    response = client.search(
        query="What are the latest breakthroughs in quantum computing?",
        max_results=5,
    )

    for result in response["results"]:
        print(f"[{result['score']:.2f}] {result['title']}")
        print(f"  {result['url']}\n")
    ```
  </Step>

  <Step title="Output">
    ```text theme={null}
    [0.92] Quantum Computing Breakthroughs in 2025 - Nature
      https://nature.com/articles/quantum-2025

    [0.87] Google Achieves New Quantum Milestone
      https://blog.google/technology/quantum/milestone-2025/

    [0.81] IBM Roadmap: 100K Qubits by 2033
      https://research.ibm.com/blog/quantum-roadmap
    ...
    ```
  </Step>
</Steps>

## Domain-Constrained Search

Restrict results to trusted sources with `include_domains`, or remove noise with `exclude_domains`.

```python theme={null}
response = client.search(
    query="CEO background at Apple",
    include_domains=["apple.com"],
    max_results=5,
)

for result in response["results"]:
    print(f"{result['title']}: {result['url']}")
```

You can also combine domain filters with exclusions:

```python theme={null}
response = client.search(
    query="enterprise AI platforms comparison",
    include_domains=["medium.com"],
    exclude_domains=["reddit.com", "quora.com"],
    search_depth="advanced",
)
```

<Tip>
  See this pattern in action in the [Product News Tracker](/examples/quick-tutorials/product-news-tracker) tutorial.
</Tip>

## Multi-Query Aggregation

For complex search operations, run multiple focused queries concurrently with `AsyncTavilyClient` and merge the results.

```python theme={null}
import os
import asyncio
from tavily import AsyncTavilyClient

async def multi_query_search():
    client = AsyncTavilyClient(api_key=os.environ["TAVILY_API_KEY"])

    queries = [
        "Competitors of Notion in the productivity space",
        "Notion financial performance and funding",
        "Recent Notion product launches and AI features",
    ]

    responses = await asyncio.gather(
        *(client.search(q, max_results=5) for q in queries),
        return_exceptions=True,
    )

    all_results = []
    for query, resp in zip(queries, responses):
        if isinstance(resp, Exception):
            print(f"Failed: {query} — {resp}")
            continue
        for r in resp["results"]:
            r["source_query"] = query
            all_results.append(r)

    seen = set()
    unique = []
    for r in sorted(all_results, key=lambda x: x["score"], reverse=True):
        if r["url"] not in seen:
            seen.add(r["url"])
            unique.append(r)

    return unique

results = asyncio.run(multi_query_search())
for r in results[:10]:
    print(f"[{r['score']:.2f}] {r['title']}")
```

<Tip>
  Breaking a broad question into 2-3 focused sub-queries often produces better results than a single long query.
</Tip>

## Critical Knobs

<AccordionGroup>
  <Accordion title="search_depth">
    * **Default:** `"basic"`
    * `"advanced"` — highest relevance, reranked chunks (2 credits)
    * `"fast"` — lower latency, chunk format (1 credit)
    * `"ultra-fast"` — near-instant, summary format (0.5 credits)
  </Accordion>

  <Accordion title="time_range / start_date / end_date">
    * `time_range` — relative filter: `"day"`, `"week"`, `"month"`, `"year"`
    * `start_date` / `end_date` — absolute date range in `YYYY-MM-DD` format
    * Use one or the other, not both
  </Accordion>

  <Accordion title="include_domains / exclude_domains">
    * Restrict results to specific domains or filter them out
    * Keep lists short for best results
  </Accordion>

  <Accordion title="max_results">
    * **Range:** 1–20, **default:** 5
    * Higher values may return lower-quality results
  </Accordion>
</AccordionGroup>

For the complete parameter list, see the [Search API reference](/documentation/api-reference/endpoint/search).

## Production Notes

* **Credits**:
  * `"basic"`, `"fast"`, and `"ultra-fast"` cost 1 credit per query.
  * `"advanced"` costs 2 credits per query.
* **Rate limits**: See [Rate Limits](/documentation/rate-limits) for current thresholds.
* **Quality filtering**: Use `score` from the response to filter low-relevance results (e.g., discard results below 0.5).
* **Async for throughput**: Use `AsyncTavilyClient` with `asyncio.gather` when making multiple concurrent requests.

## Next Steps

<CardGroup>
  <Card title="Search API Reference" icon="code" href="/documentation/api-reference/endpoint/search">
    Full parameter list, response schema, and interactive playground.
  </Card>

  <Card title="Search Best Practices" icon="gear" href="/documentation/best-practices/best-practices-search">
    Query optimization, depth selection, filtering, and post-processing tips.
  </Card>

  <Card title="Python SDK Reference" icon="python" href="/sdk/python/reference">
    Python client methods, async support, and type details.
  </Card>

  <Card title="JavaScript SDK Reference" icon="js" href="/sdk/javascript/reference">
    JavaScript/TypeScript client methods and usage.
  </Card>
</CardGroup>


# Chat
Source: https://docs.tavily.com/examples/use-cases/chat

Build a conversational chat agent with real-time web search, crawl, and extract capabilities using Tavily's API

<img alt="Tavily Chatbot Demo" />

## Try Our Chatbot

### Step 1: Get Your API Key

<Card title="Get your Tavily API key" icon="key" href="https://app.tavily.com" />

### Step 2: Chat with Tavily

<Card title="Launch the application" icon="message-bot" href="https://chat.tavily.com" />

### Step 3: Read The Open Source Code

<Card title="View Github Repository" icon="github" href="https://github.com/tavily-ai/tavily-chat" />

## Features

1. **Fast Results**: Tavily's API delivers quick responses essential for real-time chat experiences.
2. **Intelligent Parameter Selection**: Dynamically select API parameters based on conversation context using LangChain integration. Specifically designed for agentic systems. All you need is a natural language input, no need to configure structured JSON for our API.
3. **Content Snippets**: Tavily provides compact summaries of search results in the `content` field, best for maintaining small context sizes in low latency, multi-turn applications.
4. **Source Attribution**: All search, extract, and crawl results include URLs, enabling easy implementation of citations for transparency and credibility in responses.

## How Does It Work?

The chatbot uses a simple ReAct architecture to manage conversation flow and decision-making. Here's how the core components work together:

<img />

The workflow consists of several key components:

<AccordionGroup>
  <Accordion title="1. Code Snippet: Graph Structure">
    The chatbot uses LangGraph MemorySaver to manage conversation flow. The graph structure controls how messages are processed and routed.

    <Tip>
      This code snippet is not meant to run standalone. View the full implementation in our [GitHub repository](https://github.com/tavily-ai/tavily-chat).
    </Tip>

    ```python theme={null}
    class WebAgent:
        def __init__(
            self,
        ):
            self.llm = ChatOpenAI(
                model="gpt-4.1-nano", api_key=os.getenv("OPENAI_API_KEY")
            ).with_config({"tags": ["streaming"]})

            # Define the LangChain search tool
            self.search = TavilySearch(
                max_results=10, topic="general", api_key=os.getenv("TAVILY_API_KEY")
            )

            # Define the LangChain extract tool
            self.extract = TavilyExtract(
                extract_depth="advanced", api_key=os.getenv("TAVILY_API_KEY")
            )
            # Define the LangChain crawl tool
            self.crawl = TavilyCrawl(api_key=os.getenv("TAVILY_API_KEY"))
            self.prompt = PROMPT
            self.checkpointer = MemorySaver()

        def build_graph(self):
            """
            Build and compile the LangGraph workflow.
            """
            return create_react_agent(
                prompt=self.prompt,
                model=self.llm,
                tools=[self.search, self.extract, self.crawl],
                checkpointer=self.checkpointer,
            )
    ```
  </Accordion>

  <Accordion title="2. Routing Logic">
    The router decides whether to use base knowledge or perform a Tavily web search, extract, or crawl based on:

    * Question complexity
    * Need for current information
    * Available conversation context
  </Accordion>

  <Accordion title="3. Memory Management">
    The chatbot maintains conversation history using a memory system that:

    * Preserves context across multiple exchanges
    * Stores relevant search results for future reference
    * Manages system prompts and initialization
  </Accordion>

  <Accordion title="4. Real-time Search Integration">
    When Tavily access is needed, the chatbot:

    * Performs targeted web search, extract, or crawl using the LangChain integration
    * Includes source citations
  </Accordion>

  <Accordion title="5. Streaming Updates">
    Users receive real-time updates on:

    * Search progress
    * Response generation
    * Source processing
  </Accordion>
</AccordionGroup>


# Company Research
Source: https://docs.tavily.com/examples/use-cases/company-research

Perform in-depth company research with Tavily Search and Extract.

<img alt="Company Research Demo" />

## Try Our Company Researcher

### Step 1: Get Your API Key

<Card title="Get your Tavily API key" icon="key" href="https://app.tavily.com" />

### Step 2: Try the Company Researcher

<Card title="Launch the application" icon="message-bot" href="https://companyresearcher.tavily.com/" />

### Step 3: Read The Open Source Code

<Card title="View Github Repository" icon="github" href="https://github.com/pogjester/company-research-agent" />

## Why Use Tavily for company research?

<Tip>
  This is one of the most popular use cases for Tavily. Our powerful APIs can easily be integrated with agentic workflows to perform in-depth, accurate company research.
</Tip>

Tavily offers several advantages for conducting in-depth company research:

1. **Comprehensive Data Gathering**: Tavily's advanced search algorithms pull relevant information from a wide range of online sources, providing a robust foundation for in-depth company research.

2. **Flexible Agentic Search**: When Tavily is integrated into agentic workflows, such as those powered by frameworks like LangGraph, it allows AI agents to dynamically tailor their search strategies. The agents can decide to perform either a news or general search depending on the context, retrieve raw content for more in-depth analysis, or simply pull summaries when high-level insights are sufficient. This adaptability ensures that the research process is optimized according to the specific requirements of the task and the nature of the data available, bringing a new level of autonomy and intelligence to the research process.

3. **Real-time Data Retrieval**: Tavily ensures that the data used for research is up-to-date by querying live sources. This is crucial for company research where timely information can impact the accuracy and relevance of the analysis.

4. **Efficient and Scalable**: Tavily handles multiple queries simultaneously, making it capable of processing large datasets quickly. This efficiency reduces the time needed for comprehensive research, allowing for faster decision-making.


# Crawl to RAG
Source: https://docs.tavily.com/examples/use-cases/crawl-to-rag

Turn Any Website into a Searchable Knowledge Base using Tavily and MongoDB.

## The system operates through a two-step process:

### 1. Website Crawling & Vectorization:

Use Tavily's crawling endpoint to extract and sitemap content from a webpage URL, then embed it into a MongoDB Atlas vector index for retrieval.

<img alt="Vectorize" />

### 2. Intelligent Q\&A Interface:

Query your crawled data through a conversational agent that provides citation-backed answers while maintaining conversation history and context. The agent intelligently distinguishes between informational questions (requiring vector search) and conversational queries (using general knowledge).

<img alt="Chat with vector" />

## Try Our Crawl to RAG Use Case

### Step 1: Get Your API Key

<Card title="Get your Tavily API key" icon="key" href="https://app.tavily.com" />

### Step 2: Chat with Tavily

<Card title="Launch the application" icon="message-bot" href="https://crawl-to-rag.tavily.com/" />

### Step 3: Read The Open Source Code

<Card title="View Github Repository" icon="github" href="https://github.com/tavily-ai/crawl2rag" />

## Features

1. **Advanced Web Crawling**: Deep website content extraction using Tavily's crawling API
2. **Vector Search**: MongoDB Atlas vector search with OpenAI embeddings for semantic content retrieval
3. **Smart Question Routing**: Automatic detection of informational vs. conversational queries
4. **Persistent Memory**: Conversation history and context preservation using LangGraph-MongoDB checkpointing
5. **Session Management**: Thread-based conversational persistence and vector store management


# Data Enrichment
Source: https://docs.tavily.com/examples/use-cases/data-enrichment

Enhance datasets with Tavily's APIs.

#### Fill in spreadsheet columns

<img alt="Enrichment1 Demo" />

#### Enrich your spreadsheet

<img alt="Enrichment2 Demo" />

#### Export as CSV

<img alt="Enrichment3 Demo" />

## Try Our Data Enrichment Agent

### Step 1: Get Your API Key

<Card title="Get your Tavily API key" icon="key" href="https://app.tavily.com" />

### Step 2: Try the Data Enrichment Agent

<Card title="Launch the application" icon="message-bot" href="https://sheets.tavily.com/" />

### Step 3: Read The Open Source Code

<Card title="View Github Repository" icon="github" href="https://github.com/tavily-ai/tavily-sheets" />


# Market Researcher
Source: https://docs.tavily.com/examples/use-cases/market-researcher

Get comprehensive market insights and analysis for stocks in your portfolio

<img alt="Tavily Market Researcher" />

## Try Our Market Researcher

### Step 1: Get Your API Key

<Card title="Get your Tavily API key" icon="key" href="https://app.tavily.com" />

### Step 2: Try the Market Researcher

<Card title="Launch the application" icon="message-bot" href="https://market-researcher.tavily.com/" />

### Step 3: Read The Open Source Code

<Card title="View Github Repository" icon="github" href="https://github.com/tavily-ai/market-researcher" />

## Features

1. **Real-time Financial Research**: Real‑time financial news and market data aggregation performed in real-time.
2. **Full Portfolio Coverage**: Input all your stocks in your portfolio and get an analysis with comparative insights.
3. **Report Generation**: Automated report generation with source citations, so all news and claims are backed by sources.
4. **Efficient and Scalable**: Tavily handles multiple queries simultaneously, making it capable of processing large datasets quickly. This efficiency reduces the time needed for comprehensive research, allowing for faster decision-making.

## How Does It Work?

We use the Tavily 'news' and Tavily 'finance' parameters to make two separate search calls for each ticker retrieving the most relevant and up to date financial news data and metrics. All the searches are parallelized to maximize speed.


# Meeting Prep
Source: https://docs.tavily.com/examples/use-cases/meeting-prep

Build an intelligent meeting preparation agent with real-time web research capabilities using Tavily's API and Google Calendar integration

## Introduction

This repository demonstrates how to build a meeting preparation agent with real-time web access, leveraging Tavily's advanced search capabilities. This agent will connect to your Google Calendar via MCP, extract meeting information, and use Tavily search for profile research on the meeting attendees and general information on the companies you are meeting with.

<img alt="Meeting Prep Agent Demo" />

## Try Our Meeting Prep Agent

### Step 1: Get Your API Key

<Card title="Get your Tavily API key" icon="key" href="https://app.tavily.com" />

### Step 2: Read The Open Source Code and Clone the App

<Card title="View Github Repository" icon="github" href="https://github.com/tavily-ai/meeting-prep-agent" />

## System Diagram

<img alt="Meeting Prep Agent Diagram" />

## Features

1. **Real-time Web Search**: Instantly fetches up-to-date information using Tavily's search API.
2. **Agentic Reasoning**: Combines MCP and ReAct agent flows for smarter, context-aware responses.
3. **Streaming Substeps**: See agentic reasoning and substeps streamed live for transparency.
4. **Citations**: All web search results are cited for easy verification.
5. **Google Calendar Integration**: (via mcp-use) Access and analyze your meeting data.
6. **Async FastAPI Backend**: High-performance, async-ready backend for fast responses.
7. **Modern React Frontend**: Interactive UI for dynamic user interactions.


# RAG Evaluation
Source: https://docs.tavily.com/examples/use-cases/web-eval

Effortless Web-Based RAG Evaluation Using Tavily and LangGraph

# Introduction

Every data science enthusiast knows that a vital first step to building a successful model or algorithm is having a reliable evaluation set to aspire to. In the rapidly evolving landscape of **Retrieval-Augmented Generation (RAG)** and AI-driven search systems, the importance of high-quality eval datasets is crucial.

In this article, we introduce an agentic workflow designed to **generate** subject-specific dynamic **evaluation datasets**, enabling precise validation of web search augmented agents' performance.

**Known RAG evaluation datasets**, such as [HotPotQA](https://hotpotqa.github.io), [CRAG](https://github.com/facebookresearch/CRAG), and [MultiHop-RAG](https://github.com/yixuantt/MultiHop-RAG), have been pivotal in benchmarking and fine-tuning models. However, these datasets primarily focus on evaluating performance with **static, pre-defined document sets**. As a result, they fall short when it comes to evaluating **web-based RAG systems**, where data is dynamic, contextual, and ever-changing.

This gap presents a significant challenge: how do we effectively test and refine RAG systems designed for real-world web search scenarios? **Enter the Real-Time Dataset Generator for RAG Evals** — an agentic tool leveraging [Tavily’s Search Layer](https://tavily.com) and the **LangGraph framework** to create diverse, relevant, and dynamic datasets tailored specifically for web based RAG agents.

# How does it work?

<Frame>
  <img alt="Web Evaluation Graph" />
</Frame>

The Real-Time Dataset Generator follows a systematic workflow to create high-quality evaluation datasets:

<Steps>
  <Step title="Input">
    The workflow begins with user-provided inputs.
  </Step>

  <Step title="Domain-Specific Search Query Generation">
    If a subject is provided (e.g., “NBA Basketball”), the system **generates a
    set of search queries**. This ensures queries are tailored to gather
    high-quality, recent, and subject-specific information.
  </Step>

  <Step title="Web Search with Tavily">
    This step guarantees that the dataset reflects **current and relevant
    information**, particularly for web search RAG evaluation, where up-to-date
    data is crucial.This is the **heart of the RAG Dataset Generator**,
    transforming queries into actionable, high-quality data that forms the
    foundation of the evaluation set.
  </Step>

  <Step title="Q&A Pair Generation">
    For each website returned by Tavily, the system generates question-answer pair
    using a **map-reduce paradigm** to ensure efficient processing across multiple
    sources. This step is implemented using LangGraph’s Send API.
  </Step>

  <Step title="Saving the Evaluation Set">
    Finally, the generated dataset is saved either **locally** or to
    **Langsmith**, based on the input configuration.
  </Step>

  <Step title="Output">
    The result is a well-structured, subject-specific evaluation dataset, ready for use in advanced evaluation methods like **LLM-as-a-Judge**.
  </Step>
</Steps>

# Learn More

Want to dive deeper into web-based RAG evaluation? Check out these resources:

<CardGroup>
  <Card title="Blog Post" icon="newspaper" href="https://blog.tavily.com/effortless-web-based-rag-evaluation-using-tavily-and-langgraph/">
    Read our detailed blog post about generating dynamic RAG evaluation datasets
  </Card>

  <Card title="GitHub" icon="github" href="https://github.com/Eyalbenba/tavily-web-eval-generator">
    `/Eyalbenba/tavily-web-eval-generator`

    <img alt="GitHub Repo stars" />
  </Card>
</CardGroup>


# Frequently Asked Questions
Source: https://docs.tavily.com/faq/faq



<Accordion title="What is Tavily?">
  Tavily allows your AI agent to access the web, securely, and at scale. Supercharge your AI agent with real-time search, scraping, and structured data retrieval in a single API call. Tavily simplifies the process of integrating dynamic web information into AI-driven solutions.
</Accordion>

<Accordion title="What APIs does Tavily offer?">
  Tavily offers three different endpoints:

  * **Tavily Search API** - A search engine designed for AI agents, combining search and scraping capabilities.
  * **Tavily Extract API** - Scrape up to 20 URLs in a single API call.
  * **Tavily Crawl API** - Map and crawl domains efficiently.
</Accordion>

<Accordion title="What is Tavily Search API?">
  Tavily Search API is a specialized search engine designed for LLMs and AI agents. It provides real-time, customizable, and RAG-ready search results and extracted content, enabling AI applications to retrieve and process data efficiently.
</Accordion>

<Accordion title="How is Tavily Search API different from other search APIs?">
  **Traditional Search APIs:** Unlike Bing, Google, or SerpAPI, Tavily dynamically searches the web, reviews multiple sources, and extracts the most relevant content, delivering concise, ready-to-use information optimized for AI applications.

  **AI Answer Engine APIs:** Unlike Perplexity Sonar API or OpenAI Web Search API, Tavily focuses on delivering high-quality, customizable search results. Developers control search depth, domain targeting, and content extraction. LLM-generated answers are optional, making Tavily a flexible, search-first solution adaptable to different use cases.
</Accordion>

#### Features & Benefits

<Accordion title="What are the key advantages of using Tavily Search API?">
  * **Built for AI** – Designed for AI workflows like Retrieval-Augmented Generation (RAG) with structured and customizable search.
  * **Customizable** – Control search depth, target specific domains, extract full page content, and get an LLM-generated response in one API call.
  * **Real-time & Reliable** – Delivers up-to-date and real-time results.
  * **Easy Integration** – Simple API setup with support for Python, JavaScript, LangChain, and LlamaIndex.
  * **Secure & Scalable** – SOC 2 certified, zero data retention, and built to handle high-volume workloads.
</Accordion>

<Accordion title="How does Tavily ensure the accuracy of its information?">
  Tavily uses advanced algorithms and NLP techniques to gather data from trusted, authoritative sources. Users can also prioritize preferred sources to enhance relevance.
</Accordion>

<Accordion title="How fast is Tavily Search API?">
  Tavily prioritizes speed and typically returns results within seconds. Complex queries involving extensive data retrieval may take slightly longer.
</Accordion>

#### Pricing & Plans

<Accordion title="Can I test Tavily Search API before subscribing to a paid plan?">
  Yes! Tavily offers a free plan with limited monthly API calls, allowing you to test its capabilities before committing to a paid plan. No credit card is required.
</Accordion>

<Accordion title="What are the available pricing plans?">
  * **Free**: 1,000 credits/month
  * **Pay-as-you-go**: \$0.008 per credit
  * **Monthly plans**: \$0.0075 - \$0.005 per credit
  * **Enterprise**: Custom pricing and volume
</Accordion>

<Accordion title="When do my monthly API credits reset?">
  Your API credits reset on the first day of each month, regardless of the billing date. This ensures you start each month with a clean slate of credits to use for your searches.
</Accordion>

<Accordion title="How does plan upgrading or downgrading work?">
  When upgrading or downgrading your plan, charges are typically **prorated**.
  This means:

  * **Upgrading**: If you upgrade mid-cycle, you'll only pay the difference for the remaining days in your billing period.
  * **Downgrading**: Downgrades take effect at the start of the next billing cycle, and you will continue on your current plan until the cycle ends.
</Accordion>

<Accordion title="Is Tavily free for students?">
  Yes! Tavily offers free access for students. Contact [support@tavily.com](mailto:support@tavily.com) for eligibility details.
</Accordion>

#### Integration & Usage

<Accordion title="How do I integrate Tavily into my application?">
  Tavily supports Python, Node.js, and cURL. The API is simple to set up—just sign up, [get your API key](https://app.tavily.com/home), and integrate it within minutes. Visit our [SDKs](/sdk) and [API Reference](/documentation/api-reference/introduction) for more guidance and information.
</Accordion>

<Accordion title="What is GPT Researcher, and how does it relate to Tavily?">
  GPT Researcher is an open-source, autonomous research agent powered by Tavily’s Search API. It automates the research process by retrieving, filtering, and synthesizing data from over 20 web sources per task.
</Accordion>

#### Support & Privacy

<Accordion title="What level of support does Tavily provide?">
  * **Paid Subscriptions** – Email support via [support@tavily.com](mailto:support@tavily.com).
  * **Enterprise Plan** – White-glove support including:
    * Personal Slack channel
    * Dedicated account manager
    * AI engineer for technical assistance and optimizations
    * Uptime and support SLAs
</Accordion>

<Accordion title="Where can I find Tavily’s privacy policy?">
  Tavily's privacy policy is available [here](https://tavily.com/privacy), outlining how data is handled and ensuring compliance with global regulations.
</Accordion>

<Accordion title="Where can I find Tavily’s knowledge base?">
  The [Tavily Help Center](https://help.tavily.com/) is a comprehensive knowledge base with detailed guides on how to use Tavily. You can search for the information you need, explore tutorials, and find answers to common questions.
</Accordion>

#### Getting Started

<Accordion title="How do I start using Tavily?">
  1. [Sign up for an account](https://tavily.com/)
  2. [Get your API key](https://app.tavily.com/home)
  3. Integrate it into your application using our Python or Node.js SDK.
  4. Start retrieving real-time search results!
</Accordion>


# Quickstart
Source: https://docs.tavily.com/sdk/javascript/quick-start

Integrate Tavily's powerful APIs natively in your JavaScript/TypeScript projects.

<Tip>
  Looking for the JavaScript SDK Reference? Head to our [JavaScript SDK
  Reference](/sdk/javascript/reference) and learn how to use `tavily-js`.
</Tip>

## Introduction

Tavily's JavaScript SDK allows for easy interaction with the Tavily API, offering the full range of our search and extract functionalities directly from your JavaScript and TypeScript programs. Easily integrate smart search and content extraction capabilities into your applications, harnessing Tavily's powerful search and extract features.

<CardGroup>
  <Card title="GitHub" icon="github" href="https://github.com/tavily-ai/tavily-js">
    `/tavily-ai/tavily-js`

    <img alt="GitHub Repo stars" />
  </Card>

  <Card title="NPM" icon="npm" href="https://www.npmjs.com/package/@tavily/core">
    `@tavily/core`

    <img alt="GitHub Repo stars" />
  </Card>
</CardGroup>

## Quickstart

Get started with our JavaScript SDK in less than 5 minutes!

<Card title="Get your free API key" icon="key" href="https://app.tavily.com">
  You get 1,000 free API Credits every month. **No credit card required.**
</Card>

### Installation

You can install the Tavily JavaScript SDK using the following:

```bash theme={null}
npm i @tavily/core
```

### Usage

With Tavily's Python SDK, you can search the web in only 4 lines of code:

```javascript theme={null}
const { tavily } = require("@tavily/core");

const tvly = tavily({ apiKey: "tvly-YOUR_API_KEY" });
const response = await tvly.search("Who is Leo Messi?");

console.log(response);
```

You can also easily extract content from URLs:

```javascript theme={null}
const { tavily } = require("@tavily/core");

const tvly = tavily({ apiKey: "tvly-YOUR_API_KEY" });
const response = await tvly.extract(
  "https://en.wikipedia.org/wiki/Lionel_Messi"
);

console.log(response);
```

Tavily also allows you to perform a smart crawl starting at a given URL.

<Tip>
  Our agent-first crawl endpoint is currently in. Please repost any issues you encounter on our [community page](https://community.tavily.com).
</Tip>

```javascript theme={null}
const { tavily } = require("@tavily/core")

const tvly = tavily({ apiKey: "tvly-YOUR_API_KEY" });
const response = await client.crawl("https://docs.tavily.com", { instructions: "Find all pages on the Python SDK" });

console.log(response);
```

## Features

Our JavaScript SDK supports the full feature range of our [REST API](/documentation/api-reference/introduction). Our JavaScript client is asynchronous by default.

* The `search` function lets you harness the full power of Tavily Search.
* The `extract` function allows you to easily retrieve web content with Tavily Extract.
* The `crawl` and `map`functions allow you to intelligently traverse websites and extract content.


# SDK Reference
Source: https://docs.tavily.com/sdk/javascript/reference

Integrate Tavily's powerful APIs natively in your JavaScript/TypeScript projects.

## Instantiating a client

To interact with Tavily in JavaScript, you must instatiate a client with your API key. Our client is asynchronous by default.

Once you have instantiated a client, call one of our supported methods (detailed below) to access the API.

```javascript theme={null}
const { tavily } = require("@tavily/core");

client = tavily({ apiKey: "tvly-YOUR_API_KEY" });
```

### Proxies

If you would like to specify a proxy to be used when making requests, you can do so by passing in a proxy parameter on client instantiation.

Proxy configuration is available in both the synchronous and asynchronous clients.

```javascript theme={null}
const { tavily } = require("@tavily/core");

const proxies = {
  http: "<your HTTP proxy>",
  https: "<your HTTPS proxy>",
};

client = tavily({ apiKey: "tvly-YOUR_API_KEY", proxies });
```

Alternatively, you can specify which proxies to use by setting the `TAVILY_HTTP_PROXY` and `TAVILY_HTTPS_PROXY` variables in your environment file.

### Project Tracking

You can attach a Project ID to your client to organize and track API usage by project. This is useful when a single API key is used across multiple projects.

```javascript theme={null}
const { tavily } = require("@tavily/core");

const client = tavily({
  apiKey: "tvly-YOUR_API_KEY",
  projectId: "your-project-id"
});
```

Alternatively, you can set the `TAVILY_PROJECT` environment variable:

```javascript theme={null}
process.env.TAVILY_PROJECT = "your-project-id";

const client = tavily({ apiKey: "tvly-YOUR_API_KEY" });
```

All requests made with this client will include the Project ID, allowing you to filter by project in the /logs endpoint and platform usage dashboard.

### Session Tracking

You can attach session and user identifiers to your client for attribution and analytics across multi-step interactions and agent workflows. Each ID is sent as an HTTP header (`X-Session-Id`, `X-Human-Id`) on every request the client makes — across search, extract, crawl, and map.

```javascript theme={null}
const { tavily } = require("@tavily/core");

const client = tavily({
  apiKey: "tvly-YOUR_API_KEY",
  sessionId: "5874812a-2e9b-43ea-8978-6cc9225b587b",
  humanId: "h_4f9ac",
});
```

You can also override either value on a per-call basis:

```javascript theme={null}
const response = await client.search("Who is Leo Messi?", {
  sessionId: "alt-session-id",
  humanId: "alt-human-id",
});
```

For security, Tavily hashes human IDs before processing or storing them. See [Session Tracking](/documentation/api-reference/introduction#session--user-tracking) in the API reference for the underlying header contract.

## Tavily Search

<Tip>
  **NEW!** Try our interactive [API
  Playground](https://app.tavily.com/playground) to see each parameter in
  action, and generate ready-to-use JavaScript snippets.
</Tip>

You can access Tavily Search in JavaScript through the client's `search` function.

### Parameters

| Parameter                  | Type                  | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | Default     |
| :------------------------- | :-------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------- |
| `query` **(required)**     | `string`              | The query to run a search on.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | —           |
| `auto_parameters`          | `boolean`             | When `auto_parameters` is enabled, Tavily automatically configures search parameters based on your query's content and intent. You can still set other parameters manually, and your explicit values will override the automatic ones. The parameters `include_answer`, `include_raw_content`, and `max_results` must always be set manually, as they directly affect response size. Note: `search_depth` may be automatically set to advanced when it's likely to improve results. This uses 2 API credits per request. To avoid the extra cost, you can explicitly set `search_depth` to `basic`. | `false`     |
| `searchDepth`              | `string`              | The depth of the search. It can be `"basic"` or `"advanced"`. `"advanced"` search is tailored to retrieve the most relevant sources and `content` snippets for your query, while `"basic"` search provides generic content snippets from each source.                                                                                                                                                                                                                                                                                                                                               | `"basic"`   |
| `topic`                    | `string`              | The category of the search. Determines which agent will be used. Supported values are `"general"` , `"news"` and `"finance"`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `"general"` |
| `timeRange`                | `string`              | The time range back from the current date based on publish date or last updated date. Accepted values include `"day"`, `"week"`, `"month"`, `"year"` or shorthand values `"d"`, `"w"`, `"m"`, `"y"`.                                                                                                                                                                                                                                                                                                                                                                                                | —           |
| `startDate`                | `string`              | Will return all results after the specified start date based on publish date or last updated date. Required to be written in the format YYYY-MM-DD                                                                                                                                                                                                                                                                                                                                                                                                                                                  | —           |
| `endDate`                  | `string`              | Will return all results before the specified end date based on publish date or last updated date. Required to be written in the format YYYY-MM-DD.                                                                                                                                                                                                                                                                                                                                                                                                                                                  | —           |
| `maxResults`               | `number`              | The maximum number of search results to return. It must be between `0` and `20`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `5`         |
| `chunksPerSource`          | `number`              | Chunks are short content snippets (maximum 500 characters each) pulled directly from the source. Use `chunksPerSource` to define the maximum number of relevant chunks returned per source and to control the `content` length. Chunks will appear in the `content` field as: `<chunk 1> [...] <chunk 2> [...] <chunk 3>`. Available only when `searchDepth` is `"advanced"`.                                                                                                                                                                                                                       | `3`         |
| `includeImages`            | `boolean`             | Include images in the response. Returns both a top-level `images` list of query-related images and an `images` array inside each result object with images extracted from that specific source.                                                                                                                                                                                                                                                                                                                                                                                                     | `false`     |
| `includeImageDescriptions` | `boolean`             | Include a list of query-related images and their descriptions in the response.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `false`     |
| `includeAnswer`            | `boolean` or `string` | Include an answer to the query generated by an LLM based on search results. A `"basic"` (or `true`) answer is quick but less detailed; an `"advanced"` answer is more detailed.                                                                                                                                                                                                                                                                                                                                                                                                                     | `false`     |
| `includeRawContent`        | `boolean` or `string` | Include the cleaned and parsed HTML content of each search result. `"markdown"` or `True` returns search result content in markdown format. `"text"` returns the plain text from the results and may increase latency.                                                                                                                                                                                                                                                                                                                                                                              | `False`     |
| `includeDomains`           | `string[]`            | A list of domains to specifically include in the search results. Maximum 300 domains.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `[]`        |
| `excludeDomains`           | `string[]`            | A list of domains to specifically exclude from the search results. Maximum 150 domains.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `[]`        |
| `country`                  | `string`              | Boost search results from a specific country. This will prioritize content from the selected country in the search results. Available only if topic is `general`.                                                                                                                                                                                                                                                                                                                                                                                                                                   | —           |
| `timeout`                  | `number`              | A timeout to be used in requests to the Tavily API.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `60`        |
| `exactMatch`               | `boolean`             | Ensure that only search results containing the exact quoted phrase(s) in your query are returned, bypassing synonyms or semantic variations. Wrap target phrases in quotes (e.g. `"John Smith"`). Punctuation is typically ignored inside quotes.                                                                                                                                                                                                                                                                                                                                                   | `false`     |
| `includeFavicon`           | `boolean`             | Whether to include the favicon URL for each result.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `false`     |
| `includeUsage`             | `boolean`             | Whether to include credit usage information in the response.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `false`     |

### Response format

The response object you receive will be in the following format:

| Key                  | Type                          | Description                                                                                                                                                                                                                                                                                                                            |
| :------------------- | :---------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `results`            | `Result[]`                    | A list of sorted search results ranked by relevancy.                                                                                                                                                                                                                                                                                   |
| `query`              | `string`                      | Your search query.                                                                                                                                                                                                                                                                                                                     |
| `responseTime`       | `number`                      | Your search result response time.                                                                                                                                                                                                                                                                                                      |
| `requestId`          | `string`                      | A unique request identifier you can share with customer support to help resolve issues with specific requests.                                                                                                                                                                                                                         |
| `answer` (optional)  | `string`                      | The answer to your search query, generated by an LLM based on Tavily's search results. This is only available if `includeAnswer` is set to `true`.                                                                                                                                                                                     |
| `images` (optional)  | `string[]` or `ImageResult[]` | This is only available if `includeImages` is set to `true`. A list of query-related image URLs. If `includeImageDescriptions` is set to `true`, each entry will be an `ImageResult`. When `includeImages` is `true`, each result in `results` will also contain its own `images` list with images extracted from that specific source. |
| `favicon` (optional) | `string`                      | The favicon URL for the search result.                                                                                                                                                                                                                                                                                                 |

### Results

Each result in the `results` list will be in the following `Result` format:

| Key                        | Type                          | Description                                                                                                                                                                         |
| :------------------------- | :---------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `title`                    | `string`                      | The title of the search result.                                                                                                                                                     |
| `url`                      | `string`                      | The URL of the search result.                                                                                                                                                       |
| `content`                  | `string`                      | The most query-related content from the scraped URL. Tavily uses proprietary AI to extract the most relevant content based on context quality and size.                             |
| `score`                    | `float`                       | The relevance score of the search result.                                                                                                                                           |
| `rawContent` (optional)    | `string`                      | The parsed and cleaned HTML content of the site. This is only available if `includeRawContent` is set to `true`.                                                                    |
| `publishedDate` (optional) | `string`                      | The publication date of the source. This is only available if the search `topic` is set to `news`.                                                                                  |
| `favicon` (optional)       | `string`                      | The favicon URL for the result.                                                                                                                                                     |
| `images` (optional)        | `string[]` or `ImageResult[]` | Images extracted from this search result. Only included when `includeImages` is set to `true`. If `includeImageDescriptions` is set to `true`, each entry will be an `ImageResult`. |

#### Image Results

Each image in the `images` list will be in the following `ImageResult` format:

| Key                      | Type     | Description                                                                                                       |
| :----------------------- | :------- | :---------------------------------------------------------------------------------------------------------------- |
| `url`                    | `string` | The URL of the image.                                                                                             |
| `description` (optional) | `string` | This is only available if `includeImageDescriptions` is set to `true`. An LLM-generated description of the image. |

### Example

<AccordionGroup>
  <Accordion title="Request">
    ```javascript theme={null}
    const { tavily } = require("@tavily/core");

    // Step 1. Instantiating your Tavily client
    const tvly = tavily({ apiKey: "tvly-YOUR_API_KEY" });

    // Step 2. Executing a simple search query
    const response = await tvly.search("Who is Leo Messi?");

    // Step 3. That's it! You've done a Tavily Search!
    console.log(response);
    ```
  </Accordion>

  <Accordion title="Response">
    ```json theme={null}
    {
      "query": "Who is Leo Messi?",
      "images": [
        {
          "url": "Image 1 URL",
          "description": "Image 1 Description"
        },
        {
          "url": "Image 2 URL",
          "description": "Image 2 Description"
        },
        {
          "url": "Image 3 URL",
          "description": "Image 3 Description"
        },
        {
          "url": "Image 4 URL",
          "description": "Image 4 Description"
        },
        {
          "url": "Image 5 URL",
          "description": "Image 5 Description"
        }
      ],
      "results": [
        {
          "title": "Source 1 Title",
          "url": "Source 1 URL",
          "content": "Source 1 Content",
          "score": 0.99,
          "favicon": "https://source1.com/favicon.ico",
          "images": [
            {
              "url": "Source 1 Image 1 URL",
              "description": "Source 1 Image 1 Description"
            },
            {
              "url": "Source 1 Image 2 URL",
              "description": "Source 1 Image 2 Description"
            }
          ]
        },
        {
          "title": "Source 2 Title",
          "url": "Source 2 URL",
          "content": "Source 2 Content",
          "score": 0.97,
          "favicon": "https://source2.com/favicon.ico",
          "images": []
        }
      ],
      "responseTime": 1.09,
      "requestId": "123e4567-e89b-12d3-a456-426614174111"
    }
    ```
  </Accordion>
</AccordionGroup>

### Exact Match Example

Use `exactMatch` with quoted phrases in your query to find results containing a specific name or phrase verbatim:

```javascript theme={null}
const { tavily } = require("@tavily/core");

const client = tavily({ apiKey: "tvly-YOUR_API_KEY" });

const response = await client.search('"John Smith" CEO Acme Corp', {
  exactMatch: true
});
```

## Tavily Extract

You can access Tavily Extract in JavaScript through the client's `extract` function.

### Parameters

| Parameter             | Type       | Description                                                                                                                                                                                                                                                                                                                                                                                        | Default      |
| :-------------------- | :--------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------- |
| `urls` **(required)** | `string[]` | The URLs you want to extract. The list must not contain more than 20 URLs.                                                                                                                                                                                                                                                                                                                         | —            |
| `includeImages`       | `boolean`  | Include a list of images extracted from the URLs in the response.                                                                                                                                                                                                                                                                                                                                  | `false`      |
| `extractDepth`        | `string`   | The depth of the extraction process. You may experience higher latency with `"advanced"` extraction, but it offers a higher success rate and retrieves more data from the URL (e.g., tables, embedded content). `"basic"` extraction costs 1 API Credit per 5 successful URL extractions, while `"advanced"` extraction costs 2 API Credits per 5 successful URL extractions.                      | `"basic"`    |
| `format`              | `str`      | The format of the extracted web page content. `"markdown"` returns content in markdown format. `"text"` returns plain text and may increase latency.                                                                                                                                                                                                                                               | `"markdown"` |
| `timeout`             | `number`   | A timeout to be used in requests to the Tavily API.  Maximum time in seconds to wait for the URL extraction before timing out. Must be between 1.0 and 60.0 seconds. If not specified, default timeouts are applied based on extract\_depth: 10 seconds for basic extraction and 30 seconds for advanced extraction.                                                                               | `None`       |
| `includeFavicon`      | `boolean`  | Whether to include the favicon URL for each result.                                                                                                                                                                                                                                                                                                                                                | `false`      |
| `includeUsage`        | `boolean`  | Whether to include credit usage information in the response.`NOTE:`The value may be 0 if the total successful URL extractions has not yet reached 5 calls. See our [Credits & Pricing documentation](https://docs.tavily.com/documentation/api-credits) for details.                                                                                                                               | `false`      |
| `query`               | `string`   | User intent for reranking extracted content chunks. When provided, chunks are reranked based on relevance to this query.                                                                                                                                                                                                                                                                           | —            |
| `chunksPerSource`     | `number`   | Chunks are short content snippets (maximum 500 characters each) pulled directly from the source. Use `chunksPerSource` to define the maximum number of relevant chunks returned per source and to control the `rawContent` length. Chunks will appear in the `rawContent` field as: `<chunk 1> [...] <chunk 2> [...] <chunk 3>`. Available only when `query` is provided. Must be between 1 and 5. | `3`          |

### Response format

The response object you receive will be in the following format:

| Key              | Type                 | Description                                                                                                    |
| :--------------- | :------------------- | :------------------------------------------------------------------------------------------------------------- |
| `results`        | `SuccessfulResult[]` | A list of extracted content.                                                                                   |
| `failed_results` | `FailedResult[]`     | A list of URLs that could not be processed.                                                                    |
| `response_time`  | `number`             | The search result response time.                                                                               |
| `requestId`      | `string`             | A unique request identifier you can share with customer support to help resolve issues with specific requests. |

#### Successful Results

Each successful result in the `results` list will be in the following `SuccessfulResult` format:

| Key                  | Type       | Description                                                                                                      |
| :------------------- | :--------- | :--------------------------------------------------------------------------------------------------------------- |
| `url`                | `string`   | The URL of the webpage.                                                                                          |
| `raw_content`        | `string`   | The raw content extracted. When `query` is provided, contains the top-ranked chunks joined by `[...]` separator. |
| `images` (optional)  | `string[]` | This is only available if `includeImages` is set to `true`. A list of extracted image URLs.                      |
| `favicon` (optional) | `string`   | The favicon URL for the result.                                                                                  |

#### Failed Results

Each failed result in the `results` list will be in the following `FailedResult` format:

| Key     | Type     | Description                                                |
| :------ | :------- | :--------------------------------------------------------- |
| `url`   | `string` | The URL that failed.                                       |
| `error` | `string` | An error message describing why it could not be processed. |

### Example

<AccordionGroup>
  <Accordion title="Request">
    ```python theme={null}
    from tavily import TavilyClient

    # Step 1. Instantiating your TavilyClient
    tavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")

    # Step 2. Defining the list of URLs to extract content from
    urls = [
        "https://en.wikipedia.org/wiki/Artificial_intelligence",
        "https://en.wikipedia.org/wiki/Machine_learning",
        "https://en.wikipedia.org/wiki/Data_science",
    ]

    # Step 3. Executing the extract request
    response = tavily_client.extract(urls=urls, include_images=True)

    # Step 4. Printing the extracted raw content
    print(response)
    ```
  </Accordion>

  <Accordion title="Response">
    ```javascript theme={null}
    {
      "results": [
        {
          "url": "https://en.wikipedia.org/wiki/Artificial_intelligence",
          "rawContent": "URL 1 raw content",
          "images": [
            "Image 1 URL",
            "Image 2 URL"
          ],
          "favicon": "https://en.wikipedia.org/favicon.ico"
        },
        {
          "url": "https://en.wikipedia.org/wiki/Machine_learning",
          "rawContent": "URL 2 raw content",
          "images": [
            "Image 3 URL",
            "Image 4 URL"
          ],
          "favicon": "https://en.wikipedia.org/favicon.ico"
        },
        {
          "url": "https://en.wikipedia.org/wiki/Data_science",
          "rawContent": "URL 3 raw content",
          "images": [
            "Image 5 URL",
            "Image 6 URL"
          ],
          "favicon": "https://en.wikipedia.org/favicon.ico"
        }
      ],
      "failedResults": [],
      "responseTime": 1.23,
      "requestId": "123e4567-e89b-12d3-a456-426614174111"
    }
    ```
  </Accordion>
</AccordionGroup>

## Tavily Crawl

You can access Tavily Crawl in JavaScript through the client's `crawl` function.

### Parameters

| Parameter            | Type       | Description                                                                                                                                                                                                                                                                                                                                               | Default      |
| :------------------- | :--------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------- |
| `url` **(required)** | `string`   | The root URL to begin the crawl.                                                                                                                                                                                                                                                                                                                          | —            |
| `maxDepth`           | `number`   | Max depth of the crawl. Defines how far from the base URL the crawler can explore.                                                                                                                                                                                                                                                                        | `1`          |
| `maxBreadth`         | `number`   | Max number of links to follow **per level** of the tree (i.e., per page).                                                                                                                                                                                                                                                                                 | `20`         |
| `limit`              | `number`   | Total number of links the crawler will process before stopping.                                                                                                                                                                                                                                                                                           | `50`         |
| `instructions`       | `string`   | Natural language instructions for the crawler.                                                                                                                                                                                                                                                                                                            | —            |
| `selectPaths`        | `string[]` | **Regex patterns** to select only URLs with specific path patterns (e.g., `"/docs/.*"`, `"/api/v1.*"`).                                                                                                                                                                                                                                                   | `[]`         |
| `selectDomains`      | `string[]` | **Regex patterns** to select crawling to specific domains or subdomains (e.g., `"^docs\.example\.com$"`).                                                                                                                                                                                                                                                 | `[]`         |
| `excludePaths`       | `string[]` | **Regex patterns** to exclude URLs with specific path patterns (e.g., `"/admin/.*"`, `"/private/.*"`).                                                                                                                                                                                                                                                    | `[]`         |
| `excludeDomains`     | `string[]` | **Regex patterns** to exclude specific domains or subdomains from crawling (e.g., `"^admin\.example\.com$"`).                                                                                                                                                                                                                                             | `[]`         |
| `allowExternal`      | `boolean`  | Whether to return links from external domains in crawl output.                                                                                                                                                                                                                                                                                            | `true`       |
| `includeImages`      | `boolean`  | Whether to extract image URLs from the crawled pages.                                                                                                                                                                                                                                                                                                     | `false`      |
| `extractDepth`       | `string`   | Advanced extraction retrieves more data, including tables and embedded content, with higher success but may increase latency. Options: `"basic"` or `"advanced"`.                                                                                                                                                                                         | `"basic"`    |
| `format`             | `str`      | The format of the extracted web page content. `"markdown"` returns content in markdown format. `"text"` returns plain text and may increase latency.                                                                                                                                                                                                      | `"markdown"` |
| `timeout`            | `number`   | Maximum time in seconds to wait for the crawl operation before timing out. Must be between 10 and 150 seconds.                                                                                                                                                                                                                                            | `150`        |
| `includeFavicon`     | `boolean`  | Whether to include the favicon URL for each result.                                                                                                                                                                                                                                                                                                       | `false`      |
| `includeUsage`       | `boolean`  | Whether to include credit usage information in the response.`NOTE:`The value may be 0 if the total use of /extract and /map calls has not yet reached minimum needed. See our [Credits & Pricing documentation](https://docs.tavily.com/documentation/api-credits) for details.                                                                           | `false`      |
| `chunksPerSource`    | `number`   | Chunks are short content snippets (maximum 500 characters each) pulled directly from the source. Use `chunksPerSource` to define the maximum number of relevant chunks returned per source and to control the `rawContent` length. Chunks will appear in the `rawContent` field as: `<chunk 1> [...] <chunk 2> [...] <chunk 3>`. Must be between 1 and 5. | `3`          |

### Response format

The response object you receive will be in the following format:

| Key            | Type       | Description                                                                                                    |
| :------------- | :--------- | :------------------------------------------------------------------------------------------------------------- |
| `baseUrl`      | `string`   | The URL you started the crawl from.                                                                            |
| `results`      | `Result[]` | A list of crawled pages.                                                                                       |
| `responseTime` | `number`   | The crawl response time.                                                                                       |
| `requestId`    | `string`   | A unique request identifier you can share with customer support to help resolve issues with specific requests. |

#### Results

Each successful result in the `results` list will be in the following `Result` format:

| Key                  | Type       | Description                         |
| :------------------- | :--------- | :---------------------------------- |
| `url`                | `string`   | The URL of the webpage.             |
| `rawContent`         | `string`   | The raw content extracted.          |
| `images`             | `string[]` | Image URLs extracted from the page. |
| `favicon` (optional) | `string`   | The favicon URL for the result.     |

### Example

<AccordionGroup>
  <Accordion title="Request">
    ```javascript theme={null}
    const { tavily } = require("@tavily/core");

    // Step 1. Instantiating your Tavily client
    const tvly = tavily({ apiKey: "tvly-YOUR_API_KEY" });

    // Step 2. Defining the starting URL of the crawl
    const url = "https://docs.tavily.com";

    // Step 3. Executing the crawl with some guidance parameters
    const response = await client.crawl(url, { instructions: "Find all info on the Python SDK" });
      
    // Step 4. Printing the crawled results
    console.log(response);
    ```
  </Accordion>

  <Accordion title="Response">
    ````javascript theme={null}
    {
      responseTime: 9.09,
      baseUrl: "https://docs.tavily.com",
      results: [
        {
          "url": "https://docs.tavily.com/sdk/python/reference",
          "raw_content": "SDK Reference - Tavily Docs\n\n[Tavily Docs home page![light logo](https://mintlify.s3.us-west-1.amazonaws.com/tavilyai/logo/light.svg)![dark logo](https://mintlify.s3.us-west-1.amazonaws.com/tavilyai/logo/dark.svg)](https://tavily.com/)\n\nSearch or ask...\n\nCtrl K\n\n- [Support](mailto:support@tavily.com)\n- [Get an API key](https://app.tavily.com)\n- [Get an API key](https://app.tavily.com)\n\nSearch...\n\nNavigation\n\nPython\n\nSDK Reference\n\n[Home](/welcome)[Documentation](/documentation/about)[SDKs](/sdk/python/quick-start)[Examples](/examples/use-cases/data-enrichment)[FAQ](/faq/faq)\n\n- [API Playground](https://app.tavily.com/playground)\n- [Community](https://community.tavily.com)\n- [Blog](https://blog.tavily.com)\n\n##### Python\n\n- [Quickstart](/sdk/python/quick-start)\n- [SDK Reference](/sdk/python/reference)\n\n##### JavaScript\n\n- [Quickstart](/sdk/javascript/quick-start)\n- [SDK Reference](/sdk/javascript/reference)\n\nPython\n\n# SDK Reference\n\nIntegrate Tavily's powerful APIs natively in your Python apps.\n\n## [​](#instantiating-a-client) Instantiating a client\n\nTo interact with Tavily in Python, you must instatiate a client with your API key. For greater flexibility, we provide both a synchronous and an asynchronous client class.\n\nOnce you have instantiated a client, call one of our supported methods (detailed below) to access the API.\n\n### [​](#synchronous-client) Synchronous Client\n\nCopy\n\n```\nfrom tavily import TavilyClient\n\nclient = TavilyClient(\"tvly-YOUR_API_KEY\")\n\n```\n\n### [​](#asynchronous-client) Asynchronous Client\n\nCopy\n\n```\nfrom tavily import AsyncTavilyClient\n\nclient = AsyncTavilyClient(\"tvly-YOUR_API_KEY\")\n\n```\n\n### [​](#proxies) Proxies\n\nIf you would like to specify a proxy to be used when making requests, you can do so by passing in a proxy parameter on client instantiation.\n\nProxy configuration is available in both the synchronous and asynchronous clients.\n\nCopy\n\n```\nfrom tavily import TavilyClient\n\nproxies = {\n  \"http\": \"<your HTTP proxy>\",\n  \"https\": \"<your HTTPS proxy>\",\n}\n\nclient = TavilyClient(\"tvly-YOUR_API_KEY\", proxies=proxies)\n\n```\n\nAlternatively, you can specify which proxies to use by setting the `TAVILY_HTTP_PROXY` and `TAVILY_HTTPS_PROXY` variables in your environment file.\n\n## [​](#tavily-search) Tavily Search\n\n**NEW!** Try our interactive [API\nPlayground](https://app.tavily.com/playground) to see each parameter in\naction, and generate ready-to-use Python snippets.\n\nYou can access Tavily Search in Python through the client's `search` function.\n\n### [​](#parameters) Parameters\n\n| Parameter | Type | Description | Default |  |\n| --- | --- | --- | --- | --- |\n| `query` **(required)** | `str` | The query to run a search on. | — |  |\n| `search_depth` | `str` | The depth of the search. It can be `\"basic\"` or `\"advanced\"`. `\"advanced\"` search is tailored to retrieve the most relevant sources and `content` snippets for your query, while `\"basic\"` search provides generic content snippets from each source. | `\"basic\"` |  |\n| `topic` | `str` | The category of the search. Determines which agent will be used. Supported values are `\"general\"` and `\"news\"`. | `\"general\"` |  |\n| `days` | `int` | The number of days back from the current date to include in the results. Available only when using the `\"news\"` topic. | `7` |  |\n| `time_range` | `str` | The time range back from the current date. Accepted values include `\"day\"`, `\"week\"`, `\"month\"`, `\"year\"` or shorthand values `\"d\"`, `\"w\"`, `\"m\"`, `\"y\"`. | — |  |\n| `max_results` | `int` | The maximum number of search results to return. It must be between `0` and `20`. | `5` |  |\n| `chunks_per_source` | `int` | The number of `content` chunks to retrieve from each source. Each chunk's length is maximum 500 characters. It must be between `1` and `3`. Available only when `search_depth` is `advanced`. | `3` |  |\n| `include_images` | `bool` | Include a list of query-related images in the response. | `False` |  |\n| `include_image_descriptions` | `bool` | Include a list of query-related images and their descriptions in the response. | `False` |  |\n| `include_answer` | `bool` or `str` | Include an answer to the query generated by an LLM based on search results. A `\"basic\"` (or `True`) answer is quick but less detailed; an `\"advanced\"` answer is more detailed. | `False` |  |\n| `include_raw_content` | `bool` | Include the cleaned and parsed HTML content of each search result. | `False` |  |\n| `include_domains` | `list[str]` | A list of domains to specifically include in the search results. | `[]` |  |\n| `exclude_domains` | `list[str]` | A list of domains to specifically exclude from the search results. | `[]` |  |\n| `timeout` | `int` | A timeout to be used in requests to the Tavily API. | `60` |  |\n\n### [​](#response-format) Response format\n\nThe response object you receive will be in the following format:\n\n| Key | Type | Description |\n| --- | --- | --- |\n| `results` | `list[Result]` | A list of sorted search results ranked by relevancy. |\n| `query` | `str` | Your search query. |\n| `response_time` | `float` | Your search result response time. |\n| `answer` (optional) | `str` | The answer to your search query, generated by an LLM based on Tavily's search results. This is only available if `include_answer` is set to `True`. |\n| `images` (optional) | `list[str]` or `list[ImageResult]` | This is only available if `include_images` is set to `True`. A list of query-related image URLs. If `include_image_descriptions` is set to `True`, each entry will be an `ImageResult`. |\n\n### [​](#results) Results\n\n| `Key` | `Type` | Description |\n| --- | --- | --- |\n| `title` | `str` | The title of the search result. |\n| `url` | `str` | The URL of the search result. |\n| `content` | `str` | The most query-related content from the scraped URL. Tavily uses proprietary AI to extract the most relevant content based on context quality and size. |\n| `score` | `float` | The relevance score of the search result. |\n| `raw_content` (optional) | `str` | The parsed and cleaned HTML content of the site. This is only available if `include_raw_content` is set to `True`. |\n| `published_date` (optional) | `str` | The publication date of the source. This is only available if the search `topic` is set to `\"news\"`. |\n\n#### [​](#image-results) Image Results\n\nIf `includeImageDescriptions` is set to `true`, each image in the `images` list will be in the following `ImageResult` format:\n\n| Key | Type | Description |\n| --- | --- | --- |\n| `url` | `string` | The URL of the image. |\n| `description` | `string` | An LLM-generated description of the image. |\n\n### [​](#example) Example\n\nRequest\n\nCopy\n\n```\nfrom tavily import TavilyClient\n\n# Step 1. Instantiating your TavilyClient\ntavily_client = TavilyClient(api_key=\"tvly-YOUR_API_KEY\")\n\n# Step 2. Executing the search request\nresponse = tavily_client.search(\"Who is Leo Messi?\", include_images=True, include_image_descriptions=True)\n\n# Step 3. Printing the search results\nprint(response)\n\n```\n\nResponse\n\nCopy\n\n```\n{\n  \"query\": \"Who is Leo Messi?\",\n  \"images\": [\n    {\n      \"url\": \"Image 1 URL\",\n      \"description\": \"Image 1 Description\",\n    },\n    {\n      \"url\": \"Image 2 URL\",\n      \"description\": \"Image 2 Description\",\n    },\n    {\n      \"url\": \"Image 3 URL\",\n      \"description\": \"Image 3 Description\",\n    },\n    {\n      \"url\": \"Image 4 URL\",\n      \"description\": \"Image 4 Description\",\n    },\n    {\n      \"url\": \"Image 5 URL\",\n      \"description\": \"Image 5 Description\",\n    }\n  ],\n  \"results\": [\n    {\n      \"title\": \"Source 1 Title\",\n      \"url\": \"Source 1 URL\",\n      \"content\": \"Source 1 Content\",\n      \"score\": 0.99\n    },\n    {\n      \"title\": \"Source 2 Title\",\n      \"url\": \"Source 2 URL\",\n      \"content\": \"Source 2 Content\",\n      \"score\": 0.97\n    }\n  ],\n  \"response_time\": 1.09\n}\n\n```\n\n## [​](#tavily-extract) Tavily Extract\n\nYou can access Tavily Extract in Python through the client's `extract` function.\n\n### [​](#parameters-2) Parameters\n\n| Parameter | Type | Description | Default |  |\n| --- | --- | --- | --- | --- |\n| `urls` **(required)** | `str` or `list[str]` | The URL (or URLs) you want to extract. If a list is provided, it must not contain more than 20 URLs. | — |  |\n| `include_images` | `bool` | Include a list of images extracted from the URLs in the response. | `False` |  |\n| `extract_depth` | `str` | The depth of the extraction process. You may experience higher latency with `\"advanced\"` extraction, but it offers a higher success rate and retrieves more data from the URL (e.g., tables, embedded content). `\"basic\"` extraction costs 1 API Credit per 5 successful URL extractions, while `advanced` extraction costs 2 API Credits per 5 successful URL extractions. | `\"basic\"` |  |\n| `timeout` | `int` | A timeout to be used in requests to the Tavily API. | `60` |  |\n\n### [​](#response-format-2) Response format\n\nThe response object you receive will be in the following format:\n\n| Key | Type | Description |\n| --- | --- | --- |\n| `results` | `list[SuccessfulResult]` | A list of extracted content. |\n| `failed_results` | `list[FailedResult]` | A list of URLs that could not be processed. |\n| `response_time` | `float` | The search result response time. |\n\n#### [​](#successful-results) Successful Results\n\nEach successful result in the `results` list will be in the following `SuccessfulResult` format:\n\n| Key | Type | Description |\n| --- | --- | --- |\n| `url` | `str` | The URL of the webpage. |\n| `raw_content` | `str` | The raw content extracted. |\n| `images` (optional) | `list[str]` | This is only available if `include_images` is set to `True`. A list of extracted image URLs. |\n\n#### [​](#failed-results) Failed Results\n\nEach failed result in the `results` list will be in the following `FailedResult` format:\n\n| Key | Type | Description |\n| --- | --- | --- |\n| `url` | `str` | The URL that failed. |\n| `error` | `str` | An error message describing why it could not be processed. |\n\n### [​](#example-2) Example\n\nRequest\n\nCopy\n\n```\nfrom tavily import TavilyClient\n\n# Step 1. Instantiating your TavilyClient\ntavily_client = TavilyClient(api_key=\"tvly-YOUR_API_KEY\")\n\n# Step 2. Defining the list of URLs to extract content from\nurls = [\n    \"https://en.wikipedia.org/wiki/Artificial_intelligence\",\n    \"https://en.wikipedia.org/wiki/Machine_learning\",\n    \"https://en.wikipedia.org/wiki/Data_science\",\n]\n\n# Step 3. Executing the extract request\nresponse = tavily_client.extract(urls=urls, include_images=True)\n\n# Step 4. Printing the extracted raw content\nprint(response)\n\n```\n\nResponse\n\nCopy\n\n```\n{\n    \"results\": [\n        {\n            \"url\": \"https://en.wikipedia.org/wiki/Artificial_intelligence\",\n            \"raw_content\": \"URL 1 raw content\",\n            \"images\": [\n                \"Image 1 URL\",\n                \"Image 2 URL\"\n            ]\n        },\n        {\n            \"url\": \"https://en.wikipedia.org/wiki/Machine_learning\",\n            \"raw_content\": \"URL 2 raw content\",\n            \"images\": [\n                \"Image 3 URL\",\n                \"Image 4 URL\"\n            ]\n        },\n        {\n            \"url\": \"https://en.wikipedia.org/wiki/Data_science\",\n            \"raw_content\": \"URL 3 raw content\",\n            \"images\": [\n                \"Image 5 URL\",\n                \"Image 6 URL\"\n            ]\n        }\n    ],\n    \"failed_results\": [],\n    \"response_time\": 1.23\n}\n\n```\n\n## [​](#tavily-crawl) Tavily Crawl\n\nYou can access Tavily Crawl in Python through the `crawl` function.\n\n### [​](#parameters-3) Parameters\n\n| Parameter | Type | Description | Default |\n| --- | --- | --- | --- |\n| `url` **(required)** | `str` | The root URL to begin the crawl. | — |\n| `max_depth` | `int` | Max depth of the crawl. Defines how far from the base URL the crawler can explore. | `1` |\n| `max_breadth` | `int` | Max number of links to follow **per level** of the tree (i.e., per page). | `20` |\n| `limit` | `int` | Total number of links the crawler will process before stopping. | `50` |\n| `query` | `str` | Natural language instructions for the crawler. | — |\n| `select_paths` | `list[str]` | **Regex patterns** to select only URLs with specific path patterns (e.g., `\"/docs/.*\"`, `\"/api/v1.*\"`). | `None` |\n| `select_domains` | `list[str]` | **Regex patterns** to select crawling to specific domains or subdomains (e.g., `\"^docs\\.example\\.com$\"`). | `None` |\n| `allow_external` | `bool` | Whether to allow following links that go to external domains. | `False` |\n| `include_images` | `bool` | Whether to extract image URLs from the crawled pages. | `False` |\n| `extract_depth` | `str` | Advanced extraction retrieves more data, including tables and embedded content, with higher success but may increase latency. Options: `\"basic\"` or `\"advanced\"`. | `\"basic\"` |\n\n### [​](#response-format-3) Response format\n\nThe response object you receive will be in the following format:\n\n| Key | Type | Description |\n| --- | --- | --- |\n| `base_url` | `str` | The URL you started the crawl from. |\n| `results` | `list[Result]` | A list of crawled pages. |\n| `response_time` | `float` | The crawl response time. |\n\n#### [​](#results-2) Results\n\nEach successful result in the `results` list will be in the following `Result` format:\n\n| Key | Type | Description |\n| --- | --- | --- |\n| `url` | `str` | The URL of the webpage. |\n| `raw_content` | `str` | The raw content extracted. |\n| `images` | `list[str]` | Image URLs extracted from the page. |\n\n### [​](#example-3) Example\n\nRequest\n\nCopy\n\n```\nfrom tavily import TavilyClient\n\n# Step 1. Instantiating your TavilyClient\ntavily_client = TavilyClient(api_key=\"tvly-YOUR_API_KEY\")\n\n# Step 2. Defining the starting URL of the crawl\nurl = \"https://docs.tavily.com\"\n\n# Step 3. Executing the crawl with some guidance parameters\nresponse = tavily_client.crawl(url, query=\"Python SDK\")\n\n# Step 4. Printing the crawled results\nprint(response)\n\n```\n\nResponse\n\nCopy\n\n```\n{\n    \"base_url\": \"https://docs.tavily.com\",\n    \"results\": [\n        {\n            \"url\": \"https://docs.tavily.com/sdk/python/reference\",\n            \"raw_content\": \"SDK Reference - Tavily Docs\\n\\n[Tavily Docs home page![light logo](https://mintlify.s3.us-west-1.amazonaws.com/tavilyai/logo/light.svg)![dark logo](https://mintlify.s3.us-west-1.amazonaws.com/tavilyai/logo/dark.svg)](https://tavily.com/)\\n\\nSearch or ask...\\n\\nCtrl K\\n\\n- [Support](mailto:support@tavily.com)\\n- [Get an API key](https://app.tavily.com)\\n- [Get an API key](https://app.tavily.com)\\n\\nSearch...\\n\\nNavigation\\n\\nPython\\n\\nSDK Reference\\n\\n[Home](/welcome)[Documentation](/documentation/about)[SDKs](/sdk/python/quick-start)[Examples](/examples/use-cases/data-enrichment)[FAQ](/faq/faq)\\n\\n- [API Playground](https://app.tavily.com/playground)\\n- [Community](https://community.tavily.com)\\n- [Blog](https://blog.tavily.com)\\n\\n##### Python\\n\\n- [Quickstart](/sdk/python/quick-start)\\n- [SDK Reference](/sdk/python/reference)\\n\\n##### JavaScript\\n\\n- [Quickstart](/sdk/javascript/quick-start)\\n- [SDK Reference](/sdk/javascript/reference)\\n\\nPython\\n\\n# SDK Reference\\n\\nIntegrate Tavily's powerful APIs natively in your Python apps.\\n\\n## [\\u200b](#instantiating-a-client) Instantiating a client\\n\\nTo interact with Tavily in Python, you must instatiate a client with your API key. For greater flexibility, we provide both a synchronous and an asynchronous client class.\\n\\nOnce you have instantiated a client, call one of our supported methods (detailed below) to access the API.\\n\\n### [\\u200b](#synchronous-client) Synchronous Client\\n\\nCopy\\n\\n```\\nfrom tavily import TavilyClient\\n\\nclient = TavilyClient(\\\"tvly-YOUR_API_KEY\\\", proxies=proxies)\\n\\n```\\n\\n### [\\u200b](#asynchronous-client) Asynchronous Client\\n\\nCopy\\n\\n```\\nfrom tavily import AsyncTavilyClient\\n\\nclient = AsyncTavilyClient(\\\"tvly-YOUR_API_KEY\\\", proxies=proxies)\\n\\n```\\n\\n### [\\u200b](#proxies) Proxies\\n\\nIf you would like to specify a proxy to be used when making requests, you can do so by passing in a proxy parameter on client instantiation.\\n\\nProxy configuration is available in both the synchronous and asynchronous clients.\\n\\nCopy\\n\\n```\\nfrom tavily import TavilyClient\\n\\nproxies = {\\n  \\\"http\\\": \\\"<your HTTP proxy>\\\",\\n  \\\"https\\\": \\\"<your HTTPS proxy>\\\",\\n}\\n\\nclient = TavilyClient(\\\"tvly-YOUR_API_KEY\\\", proxies=proxies)\\n\\n```\\n\\nAlternatively, you can specify which proxies to use by setting the `TAVILY_HTTP_PROXY` and `TAVILY_HTTPS_PROXY` variables in your environment file.\\n\\n## [\\u200b](#tavily-search) Tavily Search\\n\\n**NEW!** Try our interactive [API\\nPlayground](https://app.tavily.com/playground) to see each parameter in\\naction, and generate ready-to-use Python snippets.\\n\\nYou can access Tavily Search in Python through the client's `search` function.\\n\\n### [\\u200b](#parameters) Parameters\\n\\n| Parameter | Type | Description | Default |  |\\n| --- | --- | --- | --- | --- |\\n| `query` **(required)** | `str` | The query to run a search on. |  |  |\\n| `search_depth` | `str` | The depth of the search. It can be `\\\"basic\\\"` or `\\\"advanced\\\"`. `\\\"advanced\\\"` search is tailored to retrieve the most relevant sources and `content` snippets for your query, while `\\\"basic\\\"` search provides generic content snippets from each source. | `\\\"basic\\\"` |  |\\n| `topic` | `str` | The category of the search. Determines which agent will be used. Supported values are `\\\"general\\\"` and `\\\"news\\\"`. | `\\\"general\\\"` |  |\\n| `days` | `int` | The number of days back from the current date to include in the results. Available only when using the `\\\"news\\\"` topic. | `7` |  |\\n| `time_range` | `str` | The time range back from the current date. Accepted values include `\\\"day\\\"`, `\\\"week\\\"`, `\\\"month\\\"`, `\\\"year\\\"` or shorthand values `\\\"d\\\"`, `\\\"w\\\"`, `\\\"m\\\"`, `\\\"y\\\"`. |  |  |\\n| `max_results` | `int` | The maximum number of search results to return. It must be between `0` and `20`. | `5` |  |\\n| `chunks_per_source` | `int` | The number of `content` chunks to retrieve from each source. Each chunk's length is maximum 500 characters. It must be between `1` and `3`. Available only when `search_depth` is `advanced`. | `3` |  |\\n| `include_images` | `bool` | Include a list of query-related images in the response. | `False` |  |\\n| `include_image_descriptions` | `bool` | Include a list of query-related images and their descriptions in the response. | `False` |  |\\n| `include_answer` | `bool` or `str` | Include an answer to the query generated by an LLM based on search results. A `\\\"basic\\\"` (or `True`) answer is quick but less detailed; an `\\\"advanced\\\"` answer is more detailed. | `False` |  |\\n| `include_raw_content` | `bool` | Include the cleaned and parsed HTML content of each search result. | `False` |  |\\n| `include_domains` | `list[str]` | A list of domains to specifically include in the search results. Maximum 300 domains.  | `[]` |  |\\n| `exclude_domains` | `list[str]` | A list of domains to specifically exclude from the search results. Maximum 150 domains. | `[]` |  |\\n| `timeout` | `int` | A timeout to be used in requests to the Tavily API. | `60` |  |\\n\\n### [\\u200b](#response-format) Response format\\n\\nThe response object you receive will be in the following format:\\n\\n| Key | Type | Description |\\n| --- | --- | --- |\\n| `results` | `list[Result]` | A list of sorted search results ranked by relevancy. |\\n| `query` | `str` | Your search query. |\\n| `response_time` | `float` | Your search result response time. |\\n| `answer` (optional) | `str` | The answer to your search query, generated by an LLM based on Tavily's search results. This is only available if `include_answer` is set to `True`. |\\n| `images` (optional) | `list[str]` or `list[ImageResult]` | This is only available if `include_images` is set to `True`. A list of query-related image URLs. If `include_image_descriptions` is set to `True`, each entry will be an `ImageResult`. |\\n\\n### [\\u200b](#results) Results\\n\\n| `Key` | `Type` | Description |\\n| --- | --- | --- |\\n| `title` | `str` | The title of the search result. |\\n| `url` | `str` | The URL of the search result. |\\n| `content` | `str` | The most query-related content from the scraped URL. Tavily uses proprietary AI to extract the most relevant content based on context quality and size. |\\n| `score` | `float` | The relevance score of the search result. |\\n| `raw_content` (optional) | `str` | The parsed and cleaned HTML content of the site. This is only available if `include_raw_content` is set to `True`. |\\n| `published_date` (optional) | `str` | The publication date of the source. This is only available if the search `topic` is set to `\\\"news\\\"`. |\\n\\n#### [\\u200b](#image-results) Image Results\\n\\nIf `includeImageDescriptions` is set to `true`, each image in the `images` list will be in the following `ImageResult` format:\\n\\n| Key | Type | Description |\\n| --- | --- | --- |\\n| `url` | `string` | The URL of the image. |\\n| `description` | `string` | An LLM-generated description of the image. |\\n\\n### [\\u200b](#example) Example\\n\\nRequest\\n\\nCopy\\n\\n```\\nfrom tavily import TavilyClient\\n\\n# Step 1. Instantiating your TavilyClient\\ntavily_client = TavilyClient(api_key=\\\"tvly-YOUR_API_KEY\\\")\\n\\n# Step 2. Executing the search request\\nresponse = tavily_client.search(\\\"Who is Leo Messi?\\\", include_images=True, include_image_descriptions=True)\\n\\n# Step 3. Printing the search results\\nprint(response)\\n\\n```\\n\\nResponse\\n\\nCopy\\n\\n```\\n{\\n  \\\"query\\\": \\\"Who is Leo Messi?\\\",\\n  \\\"images\\\": [\\n    {\\n      \\\"url\\\": \\\"Image 1 URL\\\",\\n      \\\"description\\\": \\\"Image 1 Description\\\",\\n    },\\n    {\\n      \\\"url\\\": \\\"Image 2 URL\\\",\\n      \\\"description\\\": \\\"Image 2 Description\\\",\\n    },\\n    {\\n      \\\"url\\\": \\\"Image 3 URL\\\",\\n      \\\"description\\\": \\\"Image 3 Description\\\",\\n    },\\n    {\\n      \\\"url\\\": \\\"Image 4 URL\\\",\\n      \\\"description\\\": \\\"Image 4 Description\\\",\\n    },\\n    {\\n      \\\"url\\\": \\\"Image 5 URL\\\",\\n      \\\"description\\\": \\\"Image 5 Description\\\",\\n    }\\n  ],\\n  \\\"results\\\": [\\n    {\\n      \\\"title\\\": \\\"Source 1 Title\\\",\\n      \\\"url\\\": \\\"Source 1 URL\\\",\\n      \\\"content\\\": \\\"Source 1 Content\\\",\\n      \\\"score\\\": 0.99\\n    },\\n    {\\n      \\\"title\\\": \\\"Source 2 Title\\\",\\n      \\\"url\\\": \\\"Source 2 URL\\\",\\n      \\\"content\\\": \\\"Source 2 Content\\\",\\n      \\\"score\\\": 0.97\\n    }\\n  ],\\n  \\\"response_time\\\": 1.09\\n}\\n\\n```\\n\\n## [\\u200b](#tavily-extract) Tavily Extract\\n\\nYou can access Tavily Extract in Python through the client's `extract` function.\\n\\n### [\\u200b](#parameters-2) Parameters\\n\\n| Parameter | Type | Description | Default |  |\\n| --- | --- | --- | --- | --- |\\n| `urls` **(required)** | `str` or `list[str]` | The URL (or URLs) you want to extract. If a list is provided, it must not contain more than 20 URLs. |  |  |\\n| `include_images` | `bool` | Include a list of images extracted from the URLs in the response. | `False` |  |\\n| `extract_depth` | `str` | The depth of the extraction process. You may experience higher latency with `\\\"advanced\\\"` extraction, but it offers a higher success rate and retrieves more data from the URL (e.g., tables, embedded content). `\\\"basic\\\"` extraction costs 1 API Credit per 5 successful URL extractions, while `advanced` extraction costs 2 API Credits per 5 successful URL extractions. | `\\\"basic\\\"` |  |\\n| `timeout` | `int` | A timeout to be used in requests to the Tavily API. | `60` |  |\\n\\n### [\\u200b](#response-format-2) Response format\\n\\nThe response object you receive will be in the following format:\\n\\n| Key | Type | Description |\\n| --- | --- | --- |\\n| `results` | `list[SuccessfulResult]` | A list of extracted content. |\\n| `failed_results` | `list[FailedResult]` | A list of URLs that could not be processed. |\\n| `response_time` | `float` | The search result response time. |\\n\\n#### [\\u200b](#successful-results) Successful Results\\n\\nEach successful result in the `results` list will be in the following `SuccessfulResult` format:\\n\\n| Key | Type | Description |\\n| --- | --- | --- |\\n| `url` | `str` | The URL of the webpage. |\\n| `raw_content` | `str` | The raw content extracted. |\\n| `images` (optional) | `list[str]` | This is only available if `include_images` is set to `True`. A list of extracted image URLs. |\\n\\n#### [\\u200b](#failed-results) Failed Results\\n\\nEach failed result in the `results` list will be in the following `FailedResult` format:\\n\\n| Key | Type | Description |\\n| --- | --- | --- |\\n| `url` | `str` | The URL that failed. |\\n| `error` | `str` | An error message describing why it could not be processed. |\\n\\n### [\\u200b](#example-2) Example\\n\\nRequest\\n\\nCopy\\n\\n```\\nfrom tavily import TavilyClient\\n\\n# Step 1. Instantiating your TavilyClient\\ntavily_client = TavilyClient(api_key=\\\"tvly-YOUR_API_KEY\\\")\\n\\n# Step 2. Defining the list of URLs to extract content from\\nurls = [\\n    \\\"https://en.wikipedia.org/wiki/Artificial_intelligence\\\",\\n    \\\"https://en.wikipedia.org/wiki/Machine_learning\\\",\\n    \\\"https://en.wikipedia.org/wiki/Data_science\\\",\\n]\\n\\n# Step 3. Executing the extract request\\nresponse = tavily_client.extract(urls=urls, include_images=True)\\n\\n# Step 4. Printing the extracted raw content\\nprint(response)\\n\\n```\\n\\nResponse\\n\\nCopy\\n\\n```\\n{\\n    \"results\": [\\n        {\\n            \\\"url\\\": \\\"https://en.wikipedia.org/wiki/Artificial_intelligence\\\",\\n            \\\"raw_content\\\": \\\"URL 1 raw content\\\",\\n            \\\"images\\\": [\\n                \\\"Image 1 URL\\\",\\n                \\\"Image 2 URL\\\"\\n            ]\\n        },\\n        {\\n            \\\"url\\\": \\\"https://en.wikipedia.org/wiki/Machine_learning\\\",\\n            \\\"raw_content\\\": \\\"URL 2 raw content\\\",\\n            \\\"images\\\": [\\n                \\\"Image 3 URL\\\",\\n                \\\"Image 4 URL\\\"\\n            ]\\n        },\\n        {\\n            \\\"url\\\": \\\"https://en.wikipedia.org/wiki/Data_science\\\",\\n            \\\"raw_content\\\": \\\"URL 3 raw content\\\",\\n            \\\"images\\\": [\\n                \\\"Image 5 URL\\\",\\n                \\\"Image 6 URL\\\"\\n            ]\\n        }\\n    ],\\n    \"failed_results\": [],\\n    \"response_time\": 1.23\\n}\\n\\n```\\n\\n## [\\u200b](#tavily-crawl) Tavily Crawl\\n\\nYou can access Tavily Crawl in Python through the `crawl` function.\\n\\n### [\\u200b](#parameters-3) Parameters\\n\\n| Parameter | Type | Description | Default |\n| --- | --- | --- | --- |\n| `url` **(required)** | `str` | The root URL to begin the crawl. | — |\n| `max_depth` | `int` | Max depth of the crawl. Defines how far from the base URL the crawler can explore. | `1` |\n| `max_breadth` | `int` | Max number of links to follow **per level** of the tree (i.e., per page). | `20` |\n| `limit` | `int` | Total number of links the crawler will process before stopping. | `50` |\n| `query` | `str` | Natural language instructions for the crawler. | — |\n| `select_paths` | `list[str]` | **Regex patterns** to select only URLs with specific path patterns (e.g., `\"/docs/.*\"`, `\"/api/v1.*\"`). | `None` |\n| `select_domains` | `list[str]` | **Regex patterns** to select crawling to specific domains or subdomains (e.g., `\"^docs\\.example\\.com$\"`). | `None` |\n| `allow_external` | `bool` | Whether to allow following links that go to external domains. | `False` |\n| `include_images` | `bool` | Whether to extract image URLs from the crawled pages. | `False` |\n| `extract_depth` | `str` | Advanced extraction retrieves more data, including tables and embedded content, with higher success but may increase latency. Options: `\"basic\"` or `\"advanced\"`. | `\"basic\"` |\n\n### [\\u200b](#response-format-3) Response format\\n\\nThe response object you receive will be in the following format:\\n\\n| Key | Type | Description |\\n| --- | --- | --- |\\n| `base_url` | `str` | The URL you started the crawl from. |\\n| `results` | `list[Result]` | A list of crawled pages. |\\n| `response_time` | `float` | The crawl response time. |\\n\\n#### [\\u200b](#results-2) Results\\n\\nEach successful result in the `results` list will be in the following `Result` format:\\n\\n| Key | Type | Description |\\n| --- | --- | --- |\\n| `url` | `str` | The URL of the webpage. |\\n| `raw_content` | `str` | The raw content extracted. |\\n| `images` | `list[str]` | Image URLs extracted from the page. |\\n\\n### [\\u200b](#example-3) Example\\n\\nRequest\\n\\nCopy\\n\\n```\\nfrom tavily import TavilyClient\\n\\n# Step 1. Instantiating your TavilyClient\\ntavily_client = TavilyClient(api_key=\\\"tvly-YOUR_API_KEY\\\")\\n\\n# Step 2. Defining the starting URL of the crawl\\nurl = \\\"https://docs.tavily.com\\\"\\n\\n# Step 3. Executing the crawl with some guidance parameters\\nresponse = tavily_client.crawl(url, query=\\\"Python SDK\\\")\\n\\n# Step 4. Printing the crawled results\\nprint(response)\\n\\n```\\n\\nResponse\\n\\nCopy\\n\\n```\\n{\\n    \"base_url\": \"https://docs.tavily.com\",\\n    \"results\": [\\n        {\\n            \"url\": \"https://docs.tavily.com/sdk/python/reference\",\\n            \"raw_content\": \"SDK Reference - Tavily Docs\\n\\n[Tavily Docs home page![light logo](https://mintlify.s3.us-west-1.amazonaws.com/tavilyai/logo/light.svg)![dark logo](https://mintlify.s3.us-west-1.amazonaws.com/tavilyai/logo/dark.svg)](https://tavily.com/)\\n\\nSearch or ask...\\n\\nCtrl K\\n\\n- [Support](mailto:support@tavily.com)\\n- [Get an API key](https://app.tavily.com)\\n- [Get an API key](https://app.tavily.com)\\n\\nSearch...\\n\\nNavigation\\n\\nPython\\n\\nSDK Reference\\n\\n[Home](/welcome)[Documentation](/documentation/about)[SDKs](/sdk/python/quick-start)[Examples](/examples/use-cases/data-enrichment)[FAQ](/faq/faq)\\n\\n- [API Playground](https://app.tavily.com/playground)\\n- [Community](https://community.tavily.com)\\n- [Blog](https://blog.tavily.com)\\n\\n##### Python\\n\\n- [Quickstart](/sdk/python/quick-start)\\n- [SDK Reference](/sdk/python/reference)\\n\\n##### JavaScript\\n\\n- [Quickstart](/sdk/javascript/quick-start)\\n- [SDK Reference](/sdk/javascript/reference)\\n\\nPython\\n\\n# SDK Reference\\n\\nIntegrate Tavily's powerful APIs natively in your Python apps.\\n\\n## [\\u200b](#instantiating-a-client) Instantiating a client\\n\\nTo interact with Tavily in Python, you must instatiate a client with your API key. For greater flexibility, we provide both a synchronous and an asynchronous client class.\\n\\nOnce you have instantiated a client, call one of our supported methods (detailed below) to access the API.\\n\\n### [\\u200b](#synchronous-client) Synchronous Client\\n\\nCopy\\n\\n```\\nfrom tavily import TavilyClient\\n\\nclient = TavilyClient(\\\"tvly-YOUR_API_KEY\\\", proxies=proxies)\\n\\n```\\n\\n### [\\u200b](#asynchronous-client) Asynchronous Client\\n\\nCopy\\n\\n```\\nfrom tavily import AsyncTavilyClient\\n\\nclient = AsyncTavilyClient(\\\"tvly-YOUR_API_KEY\\\", proxies=proxies)\\n\\n```\\n\\n### [\\u200b](#proxies) Proxies\\n\\nIf you would like to specify a proxy to be used when making requests, you can do so by passing in a proxy parameter on client instantiation.\\n\\nProxy configuration is available in both the synchronous and asynchronous clients.\\n\\nCopy\\n\\n```\\nfrom tavily import TavilyClient\\n\\nproxies = {\\n  \\\"http\\\": \\\"<your HTTP proxy>\\\",\\n  \\\"https\\\": \\\"<your HTTPS proxy>\\\",\\n}\\n\\nclient = TavilyClient(\\\"tvly-YOUR_API_KEY\\\", proxies=proxies)\\n\\n```\\n\\nAlternatively, you can specify which proxies to use by setting the `TAVILY_HTTP_PROXY` and `TAVILY_HTTPS_PROXY` variables in your environment file.\\n\\n## [\\u200b](#tavily-search) Tavily Search\\n\\n**NEW!** Try our interactive [API\\nPlayground](https://app.tavily.com/playground) to see each parameter in\\naction, and generate ready-to-use Python snippets.\\n\\nYou can access Tavily Search in Python through the client's `search` function.\\n\\n### [\\u200b](#parameters) Parameters\\n\\n| Parameter | Type | Description | Default |  |\\n| --- | --- | --- | --- | --- |\\n| `query` **(required)** | `str` | The query to run a search on. |  |  |\\n| `search_depth` | `str` | The depth of the search. It can be `\\\"basic\\\"` or `\\\"advanced\\\"`. `\\\"advanced\\\"` search is tailored to retrieve the most relevant sources and `content` snippets for your query, while `\\\"basic\\\"` search provides generic content snippets from each source. | `\\\"basic\\\"` |  |\\n| `topic` | `str` | The category of the search. Determines which agent will be used. Supported values are `\\\"general\\\"` and `\\\"news\\\"`. | `\\\"general\\\"` |  |\\n| `days` | `int` | The number of days back from the current date to include in the results. Available only when using the `\\\"news\\\"` topic. | `7` |  |\\n| `time_range` | `str` | The time range back from the current date. Accepted values include `\\\"day\\\"`, `\\\"week\\\"`, `\\\"month\\\"`, `\\\"year\\\"` or shorthand values `\\\"d\\\"`, `\\\"w\\\"`, `\\\"m\\\"`, `\\\"y\\\"`. |  |  |\\n| `max_results` | `int` | The maximum number of search results to return. It must be between `0` and `20`. | `5` |  |\\n| `chunks_per_source` | `int` | The number of `content` chunks to retrieve from each source. Each chunk's length is maximum 500 characters. It must be between `1` and `3`. Available only when `search_depth` is `advanced`. | `3` |  |\\n| `include_images` | `bool` | Include a list of query-related images in the response. | `False` |  |\\n| `include_image_descriptions` | `bool` | Include a list of query-related images and their descriptions in the response. | `False` |  |\\n| `include_answer` | `bool` or `str` | Include an answer to the query generated by an LLM based on search results. A `\\\"basic\\\"` (or `True`) answer is quick but less detailed; an `\\\"advanced\\\"` answer is more detailed. | `False` |  |\\n| `include_raw_content` | `bool` | Include the cleaned and parsed HTML content of each search result. | `False` |  |\\n| `include_domains` | `list[str]` | A list of domains to specifically include in the search results. | `[]` |  |\\n| `exclude_domains` | `list[str]` | A list of domains to specifically exclude from the search results. | `[]` |  |\\n| `timeout` | `int` | A timeout to be used in requests to the Tavily API. | `60` |  |\\n\\n### [\\u200b](#response-format) Response format\\n\\nThe response object you receive will be in the following format:\\n\\n| Key | Type | Description |\\n| --- | --- | --- |\\n| `results` | `list[Result]` | A list of sorted search results ranked by relevancy. |\\n| `query` | `str` | Your search query. |\\n| `response_time` | `float` | Your search result response time. |\\n| `answer` (optional) | `str` | The answer to your search query, generated by an LLM based on Tavily's search results. This is only available if `include_answer` is set to `True`. |\\n| `images` (optional) | `list[str]` or `list[ImageResult]` | This is only available if `include_images` is set to `True`. A list of query-related image URLs. If `include_image_descriptions` is set to `True`, each entry will be an `ImageResult`. |\\n\\n### [\\u200b](#results) Results\\n\\n| `Key` | `Type` | Description |\\n| --- | --- | --- |\\n| `title` | `str` | The title of the search result. |\\n| `url` | `str` | The URL of the search result. |\\n| `content` | `str` | The most query-related content from the scraped URL. Tavily uses proprietary AI to extract the most relevant content based on context quality and size. |\\n| `score` | `float` | The relevance score of the search result. |\\n| `raw_content` (optional) | `str` | The parsed and cleaned HTML content of the site. This is only available if `include_raw_content` is set to `True`. |\\n| `published_date` (optional) | `str` | The publication date of the source. This is only available if the search `topic` is set to `\\\"news\\\"`. |\\n\\n#### [\\u200b](#image-results) Image Results\\n\\nIf `includeImageDescriptions` is set to `true`, each image in the `images` list will be in the following `ImageResult` format:\\n\\n| Key | Type | Description |\\n| --- | --- | --- |\\n| `url` | `string` | The URL of the image. |\\n| `description` | `string` | An LLM-generated description of the image. |\\n\\n### [\\u200b](#example) Example\\n\\nRequest\\n\\nCopy\\n\\n```\\nfrom tavily import TavilyClient\\n\\n# Step 1. Instantiating your TavilyClient\\ntavily_client = TavilyClient(api_key=\\\"tvly-YOUR_API_KEY\\\")\\n\\n# Step 2. Executing the search request\\nresponse = tavily_client.search(\\\"Who is Leo Messi?\\\", include_images=True, include_image_descriptions=True)\\n\\n# Step 3. Printing the search results\\nprint(response)\\n\\n```\\n\\nResponse\\n\\nCopy\\n\\n```\\n{\\n  \\\"query\\\": \\\"Who is Leo Messi?\\\",\\n  \\\"images\\\": [\\n    {\\n      \\\"url\\\": \\\"Image 1 URL\\\",\\n      \\\"description\\\": \\\"Image 1 Description\\\",\\n    },\\n    {\\n      \\\"url\\\": \\\"Image 2 URL\\\",\\n      \\\"description\\\": \\\"Image 2 Description\\\",\\n    },\\n    {\\n      \\\"url\\\": \\\"Image 3 URL\\\",\\n      \\\"description\\\": \\\"Image 3 Description\\\",\\n    },\\n    {\\n      \\\"url\\\": \\\"Image 4 URL\\\",\\n      \\\"description\\\": \\\"Image 4 Description\\\",\\n    },\\n    {\\n      \\\"url\\\": \\\"Image 5 URL\\\",\\n      \\\"description\\\": \\\"Image 5 Description\\\",\\n    }\\n  ],\\n  \\\"results\\\": [\\n    {\\n      \\\"title\\\": \\\"Source 1 Title\\\",\\n      \\\"url\\\": \\\"Source 1 URL\\\",\\n      \\\"content\\\": \\\"Source 1 Content\\\",\\n      \\\"score\\\": 0.99\\n    },\\n    {\\n      \\\"title\\\": \\\"Source 2 Title\\\",\\n      \\\"url\\\": \\\"Source 2 URL\\\",\\n      \\\"content\\\": \\\"Source 2 Content\\\",\\n      \\\"score\\\": 0.97\\n    }\\n  ],\\n  \\\"response_time\\\": 1.09\\n}\\n\\n```\\n\\n## [\\u200b](#tavily-extract) Tavily Extract\\n\\nYou can access Tavily Extract in Python through the client's `extract` function.\\n\\n### [\\u200b](#parameters-2) Parameters\\n\\n| Parameter | Type | Description | Default |  |\\n| --- | --- | --- | --- | --- |\\n| `urls` **(required)** | `str` or `list[str]` | The URL (or URLs) you want to extract. If a list is provided, it must not contain more than 20 URLs. |  |  |\\n| `include_images` | `bool` | Include a list of images extracted from the URLs in the response. | `False` |  |\\n| `extract_depth` | `str` | The depth of the extraction process. You may experience higher latency with `\\\"advanced\\\"` extraction, but it offers a higher success rate and retrieves more data from the URL (e.g., tables, embedded content). `\\\"basic\\\"` extraction costs 1 API Credit per 5 successful URL extractions, while `advanced` extraction costs 2 API Credits per 5 successful URL extractions. | `\\\"basic\\\"` |  |\\n| `timeout` | `int` | A timeout to be used in requests to the Tavily API. | `60` |  |\\n\\n### [\\u200b](#response-format-2) Response format\\n\\nThe response object you receive will be in the following format:\\n\\n| Key | Type | Description |\\n| --- | --- | --- |\\n| `results` | `list[SuccessfulResult]` | A list of extracted content. |\\n| `failed_results` | `list[FailedResult]` | A list of URLs that could not be processed. |\\n| `response_time` | `float` | The search result response time. |\\n\\n#### [\\u200b](#successful-results) Successful Results\\n\\nEach successful result in the `results` list will be in the following `SuccessfulResult` format:\\n\\n| Key | Type | Description |\\n| --- | --- | --- |\\n| `url` | `str` | The URL of the webpage. |\\n| `raw_content` | `str` | The raw content extracted. |\\n| `images` (optional) | `list[str]` | This is only available if `include_images` is set to `True`. A list of extracted image URLs. |\\n\\n#### [\\u200b](#failed-results) Failed Results\\n\\nEach failed result in the `results` list will be in the following `FailedResult` format:\\n\\n| Key | Type | Description |\\n| --- | --- | --- |\\n| `url` | `str` | The URL that failed. |\\n| `error` | `str` | An error message describing why it could not be processed. |\\n\\n### [\\u200b](#example-2) Example\\n\\nRequest\\n\\nCopy\\n\\n```\\nfrom tavily import TavilyClient\\n\\n# Step 1. Instantiating your TavilyClient\\ntavily_client = TavilyClient(api_key=\\\"tvly-YOUR_API_KEY\\\")\\n\\n# Step 2. Defining the list of URLs to extract content from\\nurls = [\\n    \\\"https://en.wikipedia.org/wiki/Artificial_intelligence\\\",\\n    \\\"https://en.wikipedia.org/wiki/Machine_learning\\\",\\n    \\\"https://en.wikipedia.org/wiki/Data_science\\\",\\n]\\n\\n# Step 3. Executing the extract request\\nresponse = tavily_client.extract(urls=urls, include_images=True)\\n\\n# Step 4. Printing the extracted raw content\\nprint(response)\\n\\n```\\n\\nResponse\\n\\nCopy\\n\\n```\\n{\\n    \\\"results\\\": [\\n        {\\n            \\\"url\\\": \\\"https://en.wikipedia.org/wiki/Artificial_intelligence\\\",\\n            \\\"raw_content\\\": \\\"URL 1 raw content\\\",\\n            \\\"images\\\": [\\n                \\\"Image 1 URL\\\",\\n                \\\"Image 2 URL\\\"\\n            ]\\n        },\\n        {\\n            \\\"url\\\": \\\"https://en.wikipedia.org/wiki/Machine_learning\\\",\\n            \\\"raw_content\\\": \\\"URL 2 raw content\\\",\\n            \\\"images\\\": [\\n                \\\"Image 3 URL\\\",\\n                \\\"Image 4 URL\\\"\\n            ]\\n        },\\n        {\\n            \\\"url\\\": \\\"https://en.wikipedia.org/wiki/Data_science\\\",\\n            \\\"raw_content\\\": \\\"URL 3 raw content\\\",\\n            \\\"images\\\": [\\n                \\\"Image 5 URL\\\",\\n                \\\"Image 6 URL\\\"\\n            ]\\n        }\\n    ],\\n    \\\"failed_results\\\": [],\\n    \\\"response_time\\\": 1.23\\n}\\n\\n```\\n\\n## [\\u200b](#tavily-crawl) Tavily Crawl\\n\\nYou can access Tavily Crawl in Python through the `crawl` function.\\n\\n### [\\u200b](#parameters-3) Parameters\\n\\n| Parameter | Type | Description | Default |\\n| --- | --- | --- | --- |\\n| `url` **(required)** | `str` | The root URL to begin the crawl. | \\u2014 |\\n| `max_depth` | `int` | Max depth of the crawl. Defines how far from the base URL the crawler can explore. | `1` |\\n| `max_breadth` | `int` | Max number of links to follow **per level** of the tree (i.e., per page). | `20` |\\n| `limit` | `int` | Total number of links the crawler will process before stopping. | `50` |\\n| `query` | `str` | Natural language instructions for the crawler. | \\u2014 |\\n| `select_paths` | `list[str]` | **Regex patterns** to select only URLs with specific path patterns (e.g., `\"/docs/.*\"`, `\"/api/v1.*\"`). | `None` |\\n| `select_domains` | `list[str]` | **Regex patterns** to select crawling to specific domains or subdomains (e.g., `\"^docs\\\\.example\\\\.com$\\\"`). | `None` |\\n| `allow_external` | `bool` | Whether to allow following links that go to external domains. | `False` |\\n| `include_images` | `bool` | Whether to extract image URLs from the crawled pages. | `False` |\\n| `extract_depth` | `str` | Advanced extraction retrieves more data, including tables and embedded content, with higher success but may increase latency. Options: `\\\"basic\\\"` or `\\\"advanced\\\"`. | `\\\"basic\\\"` |\\n\\n### [\\u200b](#response-format-3) Response format\\n\\nThe response object you receive will be in the following format:\\n\\n| Key | Type | Description |\\n| --- | --- | --- |\\n| `base_url` | `str` | The URL you started the crawl from. |\\n| `results` | `list[Result]` | A list of crawled pages. |\\n| `response_time` | `float` | The crawl response time. |\\n\\n#### [\\u200b](#results-2) Results\\n\\nEach successful result in the `results` list will be in the following `Result` format:\\n\\n| Key | Type | Description |\\n| --- | --- | --- |\\n| `url` | `str` | The URL of the webpage. |\\n| `raw_content` | `str` | The raw content extracted. |\\n\\n### [\\u200b](#example-3) Example\\n\\nRequest\\n\\nCopy\\n\\n```\\nfrom tavily import TavilyClient\\n\\n# Step 1. Instantiating your TavilyClient\\ntavily_client = TavilyClient(api_key=\\\"tvly-YOUR_API_KEY\\\")\\n\\n# Step 2. Defining the starting URL of the crawl\\nurl = \\\"https://docs.tavily.com\\\"\\n\\n# Step 3. Executing the crawl with some guidance parameters\\nresponse = tavily_client.crawl(url, query=\\\"Python SDK\\\")\\n\\n# Step 4. Printing the crawled results\\nprint(response)\\n\\n```\\n\\nResponse\\n\\nCopy\\n\\n```\\n{\\n    'base_url': 'https://docs.tavily.com',\\n    'results': [\\n        {\\n            'url': 'https://docs.tavily.com/sdk/python/quick-start',\\n            'raw_content': 'Quickstart - Tavily Docs\\\\n\\\\n[Tavily Docs home page![light logo](https://mintlify.s3.us-west-1.amazonaws.com/tavilyai/logo/light.svg)![dark logo](https://mintlify.s3.us-west-1.amazonaws.com/tavilyai/logo/dark.svg)](https://tavily.com/)\\\\n\\\\nSearch or ask...\\\\n\\\\nCtrl K\\\\n\\\\n- [Support](mailto:support@tavily.com)\\\\n- [Get an API key](https://app.tavily.com)\\\\n- [Get an API key](https://app.tavily.com)\\\\n\\\\nSearch...\\\\n\\\\nNavigation\\\\n\\\\nPython\\\\n\\\\nQuickstart\\\\n\\\\n[Home](/welcome)[Documentation](/documentation/about)[SDKs](/sdk/python/quick-start)[Examples](/examples/use-cases/data-enrichment)[FAQ](/faq/faq)\\\\n\\\\n- [API Playground](https://app.tavily.com/playground)\\\\n- [Community](https://community.tavily.com)\\\\n- [Blog](https://blog.tavily.com)\\\\n\\\\n##### Python\\\\n\\\\n- [Quickstart](/sdk/python/quick-start)\\\\n- [SDK Reference](/sdk/python/reference)\\\\n\\\\n##### JavaScript\\\\n\\\\n- [Quickstart](/sdk/javascript/quick-start)\\\\n- [SDK Reference](/sdk/javascript/reference)\\\\n\\\\nPython\\\\n\\\\n# Quickstart\\\\n\\\\nIntegrate Tavily\\\\'s powerful APIs natively in your Python apps.\\\\n\\\\nLooking for the Python SDK Reference? Head to our [Python SDK Reference](/sdk/python/reference) and learn how to use `tavily-python`.\\\\n\\\\n## [\\\\u200b](#introduction) Introduction\\\\n\\\\nThe Python SDK allows for easy interaction with the Tavily API, offering the full range of our search functionality directly from your Python programs. Easily integrate smart search capabilities into your applications, harnessing Tavily\\\\'s powerful search features.\\\\n\\\\n[## GitHub\\\\n\\\\n`/tavily-ai/tavily-python`\\\\n\\\\n![GitHub Repo stars](https://img.shields.io/github/stars/tavily-ai/tavily-python?style=social)](https://github.com/tavily-ai/tavily-python)[## PyPI\\\\n\\\\n`tavily-python`\\\\n\\\\n![PyPI downloads](https://img.shields.io/pypi/dm/tavily-python)](https://pypi.org/project/tavily-python)\\\\n\\\\n## [\\\\u200b](#quickstart) Quickstart\\\\n\\\\nGet started with our Python SDK in less than 5 minutes!\\\\n\\\\n[## Get your free API key\\\\n\\\\nYou get 1,000 free API Credits every month. **No credit card required.**](https://app.tavily.com)\\\\n\\\\n### [\\\\u200b](#installation) Installation\\\\n\\\\nYou can install the Tavily Python SDK using the following:\\\\n\\\\nCopy\\\\n\\\\n```\\\\npip install tavily-python\\\\n\\\\n```\\\\n\\\\n### [\\\\u200b](#usage) Usage\\\\n\\\\nWith Tavily\\\\'s Python SDK, you can search the web in only 4 lines of code:\\\\n\\\\nCopy\\\\n\\\\n```\\\\nfrom tavily import TavilyClient\\\\n\\\\ntavily_client = TavilyClient(api_key=\\\"tvly-YOUR_API_KEY\\\")\\\\nresponse = tavily_client.search(\\\"Who is Leo Messi?\\\")\\\\n\\\\nprint(response)\\\\n\\\\n```\\\\n\\\\nYou can also easily extract content from URLs:\\\\n\\\\nCopy\\\\n\\\\n```\\\\nfrom tavily import TavilyClient\\\\n\\\\ntavily_client = TavilyClient(api_key=\\\"tvly-YOUR_API_KEY\\\")\\\\nresponse = tavily_client.extract(\\\"https://en.wikipedia.org/wiki/Lionel_Messi\\\")\\\\n\\\\nprint(response)\\\\n\\\\n```\\\\n\\\\nThese examples are very simple, and you can do so much more with Tavily!\\\\n\\\\n## [\\\\u200b](#features) Features\\\\n\\\\nOur Python SDK supports the full feature range of our [REST API](/api-reference), and more. We offer both a synchronous and an asynchronous client, for increased flexibility.\\\\n\\\\n- The `search` function lets you harness the full power of Tavily Search.\\\\n- The `extract` function allows you to easily retrieve web content with Tavily Extract.\\\\n\\\\nFor more details, head to the [Python SDK Reference](/sdk/python/reference).\\\\n\\\\n[SDK Reference](/sdk/python/reference)\\\\n\\\\n[x](https://x.com/tavilyai)[github](https://github.com/tavily-ai)[linkedin](https://linkedin.com/company/tavily)[website](https://tavily.com)\\\\n\\\\n[Powered by Mintlify](https://mintlify.com/preview-request?utm_campaign=poweredBy&utm_medium=docs&utm_source=docs.tavily.com)\\\\n\\\\nOn this page\\\\n\\\\n- [Introduction](#introduction)\\\\n- [Quickstart](#quickstart)\\\\n- [Installation](#installation)\\\\n- [Usage](#usage)\\\\n- [Features](#features)'\\n        }\\n    ],\\n    'response_time': 9.14\\n}\\n\\n```\\n\\n## [\\u200b](#tavily-map) Tavily Map\\n\\nTavily Map allows you to obtain a sitemap starting from a base URL.\\n\\nYou can access Tavily Map in Python through the `map` function.\\n\\n### [\\u200b](#parameters-4) Parameters\\n\\n| Parameter | Type | Description | Default |\\n| --- | --- | --- | --- |\\n| `url` **(required)** | `str` | The root URL to begin the mapping. | \\u2014 |\\n| `max_depth` | `int` | Max depth of the mapping. Defines how far from the base URL the crawler can explore. | `1` |\\n| `max_breadth` | `int` | Max number of links to follow **per level** of the tree (i.e., per page). | `20` |\\n| `limit` | `int` | Total number of links the crawler will process before stopping. | `50` |\\n| `query` | `str` | Natural language instructions for the crawler | \\u2014 |\\n| `select_paths` | `str[]` | **Regex patterns** to select only URLs with specific path patterns (e.g., `\\\"/docs/.*\\\"`, `\\\"/api/v1.*\\\"`). | `None` |\\n| `select_domains` | `str[]` | **Regex patterns** to select crawling to specific domains or subdomains (e.g., `\\\"^docs\\\\.example\\\\.com$\\\"`). | `None` |\\n| `allow_external` | `bool` | Whether to allow following links that go to external domains. | `False` |\\n\\n### [\\u200b](#response-format-4) Response format\\n\\nThe response object you receive will be in the following format:\\n\\n| Key | Type | Description |\\n| --- | --- | --- |\\n| `base_url` | `str` | The URL you started the mapping from. |\\n| `results` | `list[str]` | A list of URLs that were discovered during the mapping. |\\n| `response_time` | `float` | The mapping response time. |\\n\\n### [\\u200b](#example-4) Example\\n\\nRequest\\n\\nCopy\\n\\n```\\nfrom tavily import TavilyClient\\n\\n# Step 1. Instantiating your TavilyClient\\ntavily_client = TavilyClient(api_key=\\\"tvly-YOUR_API_KEY\\\")\\n\\n# Step 2. Defining the starting URL of the mapping\\nurl = \\\"https://docs.tavily.com\\\"\\n\\n# Step 3. Executing the mapping with some guidance parameters\\nresponse = tavily_client.mapping(url, query=\\\"JavaScript\\\")\\n\\n# Step 4. Printing the results\\nprint(response)\\n\\n```\\n\\nResponse\\n\\nCopy\\n\\n```\\n{\\n    'base_url': 'https://docs.tavily.com',\\n    'results': [\\n      'https://docs.tavily.com/sdk/javascript/quick-start',\\n      'https://docs.tavily.com/sdk/javascript/reference',\\n    ],\\n    'response_time': 8.43\\n}\\n\\n```\\n\\n## [\\u200b](#tavily-hybrid-rag) Tavily Hybrid RAG\\n\\nTavily Hybrid RAG is an extension of the Tavily Search API built to retrieve relevant data from both the web and an existing database collection. This way, a RAG agent can combine web sources and locally available data to perform its tasks. Additionally, data queried from the web that is not yet in the database can optionally be inserted into it. This will allow similar searches in the future to be answered faster, without the need to query the web again.\\n\\n### [\\u200b](#parameters-5) Parameters\\n\\nThe TavilyHybridClient class is your gateway to Tavily Hybrid RAG. There are a few important parameters to keep in mind when you are instantiating a Tavily Hybrid Client.\\n\\n| Parameter | Type | Description | Default |\\n| --- | --- | --- | --- |\\n| `api_key` | `str` | Your Tavily API Key |  |\\n| `db_provider` | `str` | Your database provider. Currently, only `\\\"mongodb\\\"` is supported. |  |\\n| `collection` | `str` | A reference to the MongoDB collection that will be used for local search. |  |\\n| `embeddings_field` (optional) | `str` | The name of the field that stores the embeddings in the specified collection. This field MUST be the same one used in the specified index. This will also be used when inserting web search results in the database using our default function. | `\\\"embeddings\\\"` |\\n| `content_field` (optional) | `str` | The name of the field that stores the text content in the specified collection. This will also be used when inserting web search results in the database using our default function. | `\\\"content\\\"` |\\n| `embedding_function` (optional) | `function` | A custom embedding function (if you want to use one). The function must take in a `list[str]` corresponding to the list of strings to be embedded, as well as an additional string defining the type of document. It must return a `list[list[float]]`, one embedding per input string. If no function is provided, defaults to Cohere\\u2019s Embed. Keep in mind that you shouldn\\u2019t mix different embeddings in the same database collection. |  |\\n| `ranking_function` (optional) | `function` | A custom ranking function (if you want to use one). If no function is provided, defaults to Cohere\\u2019s Rerank. It should return an ordered `list[dict]` where the documents are sorted by decreasing relevancy to your query. Each returned document will have two properties - `content`, which is a `str`, and `score`, which is a `float`. The function MUST accept the following parameters: `query`: `str` - This is the query you are executing. When your ranking function is called during Hybrid RAG, the query parameter of your search call (more details below) will be passed as query. `documents`:`List[Dict]`: - This is the list of documents that are returned by your Hybrid RAG call and that you want to sort. Each document will have two properties - `content`, which is a `str`, and `score`, which is a `float`. `top_n`: `int` - This is the number of results you want to return after ranking. When your ranking function is called during Hybrid RAG, the max\\\\_results value will be passed as `top_n`. |  |\\n\\n### [\\u200b](#methods) Methods\\n\\n`search`(query, max\\\\_results=10, max\\\\_local=None, max\\\\_foreign=None, save\\\\_foreign=False, \\\\*\\\\*kwargs)\\n\\nPerforms a Tavily Hybrid RAG query and returns the retrieved documents as a `list[dict]` where the documents are sorted by decreasing relevancy to your query. Each returned document will have three properties - `content` (str), `score` (float), and `origin`, which is either `local` or `foreign`.\\n\\n| Parameter | Type | Description | Default |  |\\n| --- | --- | --- | --- | --- |\\n| `query` | `str` | The query you want to search for. |  |  |\\n| `max_results` | `int` | The maximum number of total search results to return. | 10 |  |\\n| `max_local` | `int` | The maximum number of local search results to return. | `None`, which defaults to `max_results`. |  |\\n| `max_local` | `int` | The maximum number of local search results to return. | `None`, which defaults to `max_results`. |  |\\n| `max_foreign` | `int` | The maximum number of web search results to return. | `None`, which defaults to `max_results`. |  |\\n| `save_foreign` | `Union[bool, function]` | Save documents from the web search in the local database. If `True` is passed, our default saving function (which only saves the content `str` and the embedding `list[float]` will be used.) If `False` is passed, no web search result documents will be saved in the local database. If a function is passed, that function MUST take in a `dict` as a parameter, and return another `dict`. The input `dict` contains all properties of the returned Tavily result object. The output dict is the final document that will be inserted in the database. You are free to add to it any fields that are supported by the database, as well as remove any of the default ones. If this function returns `None`, the document will not be saved in the database. |  |  |\\n\\nAdditional parameters can be provided as keyword arguments (detailed below). The keyword arguments supported by this method are: `search_depth`, `topic`, `include_raw_content`, `include_domains`,`exclude_domains`.\\n\\n### [\\u200b](#setup) Setup\\n\\n#### [\\u200b](#mongodb-setup) MongoDB setup\\n\\nYou will need to have a MongoDB collection with a vector search index. You can follow the [MongoDB Documentation](https://www.mongodb.com/docs/atlas/atlas-vector-search/vector-search-type/) to learn how to set this up.\\n\\n#### [\\u200b](#cohere-api-key) Cohere API Key\\n\\nBy default, embedding and ranking use the Cohere API, our recommended option. Unless you want to provide a custom embedding and ranking function, you\\u2019ll need to get an API key from [Cohere](https://cohere.com/) and set it as an environment variable named `CO_API_KEY`\\n\\nIf you decide to stick with Cohere, please note that you\\u2019ll need to install the Cohere Python package as well:\\n\\nCopy\\n\\n```\\npip install cohere\\n\\n```\\n\\n#### [\\u200b](#tavily-hybrid-rag-client-setup) Tavily Hybrid RAG Client setup\\n\\nOnce you are done setting up your database, you\\u2019ll need to create a MongoDB Client as well as a Tavily Hybrid RAG Client.\\nA minimal setup would look like this:\\n\\nCopy\\n\\n```\\nfrom pymongo import MongoClient\\nfrom tavily import TavilyHybridClient\\n\\ndb = MongoClient(\\\"mongodb+srv://YOUR_MONGO_URI\\\")[\\\"YOUR_DB\\\"]\\n\\nhybrid_rag = TavilyHybridClient(\\n    api_key=\\\"tvly-YOUR_API_KEY\\\",\\n    db_provider=\\\"mongodb\\\",\\n    collection=db.get_collection(\\\"YOUR_COLLECTION\\\"),\\n    index=\\\"YOUR_VECTOR_SEARCH_INDEX\\\",\\n    embeddings_field=\\\"YOUR_EMBEDDINGS_FIELD\\\",\\n    content_field=\\\"YOUR_CONTENT_FIELD\\\"\\n)\\n\\n```\\n\\n### [\\u200b](#usage) Usage\\n\\nOnce you create the proper clients, you can easily start searching. A few simple examples are shown below. They assume you\\u2019ve followed earlier steps. You can use most of the Tavily Search parameters with Tavily Hybrid RAG as well.\\n\\n#### [\\u200b](#simple-tavily-hybrid-rag-example) Simple Tavily Hybrid RAG example\\n\\nThis example will look for context about Leo Messi on the web and in the local database.\\nHere, we get 5 sources, both from our database and from the web, but we want to exclude unwanted-domain.com from our web search results:\\n\\nCopy\\n\\n```\\nresults = hybrid_rag.search(\\\"Who is Leo Messi?\\\", max_results=5, exclude_domains=['unwanted-domain.com'])\\n\\n```\\n\\nHere, we want to prioritize the number of local sources, so we will get 2 foreign (web) sources, and 5 sources from our database:\\n\\nCopy\\n\\n```\\nresults = hybrid_rag.search(\\\"Who is Leo Messi?\\\",  max_local=5, max_foreign=2)\\n\\n```\\n\\nNote: The sum of `max_local` and `max_foreign` can exceed `max_results`, but only the top `max_results` results will be returned.\\n\\n#### [\\u200b](#adding-retrieved-data-to-the-database) Adding retrieved data to the database\\n\\nIf you want to add the retrieved data to the database, you can do so by setting the save\\\\_foreign parameter to True:\\n\\nCopy\\n\\n```\\nresults = hybrid_rag.search(\\\"Who is Leo Messi?\\\", save_foreign=True)\\n\\n```\\n\\nThis will use our default saving function, which stores the content and its embedding.\\n\\n### [\\u200b](#examples) Examples\\n\\n#### [\\u200b](#sample-1%3A-using-a-custom-saving-function) Sample 1: Using a custom saving function\\n\\nYou might want to add some extra properties to documents you\\u2019re inserting or even discard some of them based on custom criteria. This can be done by passing a function to the save\\\\_foreign parameter:\\n\\nCopy\\n\\n```\\ndef save_document(document):\\n    if document['score'] < 0.5:\\n        return None # Do not save documents with low scores\\n\\n    return {\\n        'content': document['content'],\\n\\n         # Save the title and URL in the database\\n        'site_title': document['title'],\\n        'site_url': document['url'],\\n\\n        # Add a new field\\n        'added_at': datetime.now()\\n    }\\n\\nresults = hybrid_rag.search(\\\"Who is Leo Messi?\\\", save_foreign=save_document)\\n\\n```\\n\\n#### [\\u200b](#sample-2%3A-using-a-custom-embedding-function) Sample 2: Using a custom embedding function\\n\\nBy default, we use [Cohere](https://cohere.com/) for our embeddings. If you want to use your own embeddings, can pass a custom embedding function to the TavilyHybridClient:\\n\\nCopy\\n\\n```\\ndef my_embedding_function(texts, doc_type): # doc_type will be either 'search_query' or 'search_document'\\n    return my_embedding_model.encode(texts)\\n\\nhybrid_rag = TavilyHybridClient(\\n    # ...\\n    embedding_function=my_embedding_function\\n)\\n\\n```\\n\\n#### [\\u200b](#sample-3%3A-using-a-custom-ranking-function) Sample 3: Using a custom ranking function\\n\\nCohere\\u2019s [rerank](https://cohere.com/rerank) model is used by default, but you can pass your own function to the ranking\\\\_function parameter:\\n\\nCopy\\n\\n```\\ndef my_ranking_function(query, documents, top_n):\\n    return my_ranking_model.rank(query, documents, top_n)\\n\\nhybrid_rag = TavilyHybridClient(\\n    # ...\\n    ranking_function=my_ranking_function\\n)\\n\\n```\\n\\n[Quickstart](/sdk/python/quick-start)[Quickstart](/sdk/javascript/quick-start)\\n\\n[x](https://x.com/tavilyai)[github](https://github.com/tavily-ai)[linkedin](https://linkedin.com/company/tavily)[website](https://tavily.com)\\n\\n[Powered by Mintlify](https://mintlify.com/preview-request?utm_campaign=poweredBy&utm_medium=docs&utm_source=docs.tavily.com)\\n\\nOn this page\\n\\n- [Instantiating a client](#instantiating-a-client)\\n- [Synchronous Client](#synchronous-client)\\n- [Asynchronous Client](#asynchronous-client)\\n- [Proxies](#proxies)\\n- [Tavily Search](#tavily-search)\\n- [Parameters](#parameters)\\n- [Response format](#response-format)\\n- [Results](#results)\\n- [Image Results](#image-results)\\n- [Example](#example)\\n- [Tavily Extract](#tavily-extract)\\n- [Parameters](#parameters-2)\\n- [Response format](#response-format-2)\\n- [Successful Results](#successful-results)\\n- [Failed Results](#failed-results)\\n- [Example](#example-2)\\n- [Tavily Crawl](#tavily-crawl)\\n- [Parameters](#parameters-3)\\n- [Response format](#response-format-3)\\n- [Results](#results-2)\\n- [Example](#example-3)\\n- [Tavily Map](#tavily-map)\\n- [Parameters](#parameters-4)\\n- [Response format](#response-format-4)\\n- [Example](#example-4)\\n- [Tavily Hybrid RAG](#tavily-hybrid-rag)\\n- [Parameters](#parameters-5)\\n- [Methods](#methods)\\n- [Setup](#setup)\\n- [MongoDB setup](#mongodb-setup)\\n- [Cohere API Key](#cohere-api-key)\\n- [Tavily Hybrid RAG Client setup](#tavily-hybrid-rag-client-setup)\\n- [Usage](#usage)\\n- [Simple Tavily Hybrid RAG example](#simple-tavily-hybrid-rag-example)\\n- [Adding retrieved data to the database](#adding-retrieved-data-to-the-database)\\n- [Examples](#examples)\\n- [Sample 1: Using a custom saving function](#sample-1%3A-using-a-custom-saving-function)\\n- [Sample 2: Using a custom embedding function](#sample-2%3A-using-a-custom-embedding-function)\\n- [Sample 3: Using a custom ranking function](#sample-3%3A-using-a-custom-ranking-function)\",\n            \"images\": []\n        },\n        {\n            \"url\": \"https://docs.tavily.com/sdk/python/quick-start\",\n            \"raw_content\": \"Quickstart - Tavily Docs\\n\\n[Tavily Docs home page![light logo](https://mintlify.s3.us-west-1.amazonaws.com/tavilyai/logo/light.svg)![dark logo](https://mintlify.s3.us-west-1.amazonaws.com/tavilyai/logo/dark.svg)](https://tavily.com/)\\n\\nSearch or ask...\\n\\nCtrl K\\n\\n- [Support](mailto:support@tavily.com)\\n- [Get an API key](https://app.tavily.com)\\n- [Get an API key](https://app.tavily.com)\\n\\nSearch...\\n\\nNavigation\\n\\nPython\\n\\nQuickstart\\n\\n[Home](/welcome)[Documentation](/documentation/about)[SDKs](/sdk/python/quick-start)[Examples](/examples/use-cases/data-enrichment)[FAQ](/faq/faq)\n\n- [API Playground](https://app.tavily.com/playground)\n- [Community](https://community.tavily.com)\n- [Blog](https://blog.tavily.com)\n\n##### Python\n\n- [Quickstart](/sdk/python/quick-start)\n- [SDK Reference](/sdk/python/reference)\n\n##### JavaScript\n\n- [Quickstart](/sdk/javascript/quick-start)\n- [SDK Reference](/sdk/javascript/reference)\n\nPython\n\n# Quickstart\n\nIntegrate Tavily's powerful APIs natively in your Python apps.\n\nLooking for the Python SDK Reference? Head to our [Python SDK Reference](/sdk/python/reference) and learn how to use `tavily-python`.\n\n## [](#introduction) Introduction\n\nThe Python SDK allows for easy interaction with the Tavily API, offering the full range of our search functionality directly from your Python programs. Easily integrate smart search capabilities into your applications, harnessing Tavily's powerful search features.\n\n[## GitHub\n\n`/tavily-ai/tavily-python`\n\n![GitHub Repo stars](https://img.shields.io/github/stars/tavily-ai/tavily-python?style=social)](https://github.com/tavily-ai/tavily-python)[## PyPI\n\n`tavily-python`\n\n![PyPI downloads](https://img.shields.io/pypi/dm/tavily-python)](https://pypi.org/project/tavily-python)\n\n## [](#quickstart) Quickstart\n\nGet started with our Python SDK in less than 5 minutes!\n\n[## Get your free API key\n\nYou get 1,000 free API Credits every month. **No credit card required.**](https://app.tavily.com)\n\n### [](#installation) Installation\n\nYou can install the Tavily Python SDK using the following:\n\nCopy\n\n```\npip install tavily-python\n\n```\n\n### [](#usage) Usage\n\nWith Tavily's Python SDK, you can search the web in only 4 lines of code:\n\nCopy\n\n```\nfrom tavily import TavilyClient\n\ntavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")\nresponse = tavily_client.search("Who is Leo Messi?")\n\nprint(response)\n\n```\n\nYou can also easily extract content from URLs:\n\nCopy\n\n```\nfrom tavily import TavilyClient\n\ntavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")\nresponse = tavily_client.extract("https://en.wikipedia.org/wiki/Lionel_Messi")\n\nprint(response)\n\n```\n\nTavily also allows you to perform a smart crawl starting at a given URL.\n\nCopy\n\n```\nfrom tavily import TavilyClient\n\ntavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")\nresponse = tavily_client.crawl("https://docs.tavily.com", query="Python SDK")\n\nprint(response)\n\n```\n\nThese examples are very simple, and you can do so much more with Tavily!\n\n## [](#features) Features\n\nOur Python SDK supports the full feature range of our [REST API](/api-reference), and more. We offer both a synchronous and an asynchronous client, for increased flexibility.\n\n- The `search` function lets you harness the full power of Tavily Search.\n- The `extract` function allows you to easily retrieve web content with Tavily Extract.\n\nFor more details, head to the [Python SDK Reference](/sdk/python/reference).\n\n[SDK Reference](/sdk/python/reference)\n\n[x](https://x.com/tavilyai)[github](https://github.com/tavily-ai)[linkedin](https://linkedin.com/company/tavily)[website](https://tavily.com)\n\n[Powered by Mintlify](https://mintlify.com/preview-request?utm_campaign=poweredBy&utm_medium=docs&utm_source=docs.tavily.com)\n\nOn this page\n\n- [Introduction](#introduction)\n- [Quickstart](#quickstart)\n- [Installation](#installation)\n- [Usage](#usage)\n- [Features](#features)",
          images: [],
          "favicon": "https://mintlify.s3-us-west-1.amazonaws.com/tavilyai/_generated/favicon/apple-touch-icon.png?v=3"
        },
        {
          "url": "https://docs.tavily.com/docs/python-sdk/tavily-search/getting-started",
          "raw_content": "Welcome - Tavily Docs\n\n[Tavily Docs home page![light logo](https://mintlify.s3.us-west-1.amazonaws.com/tavilyai/logo/light.svg)![dark logo](https://mintlify.s3.us-west-1.amazonaws.com/tavilyai/logo/dark.svg)](https://tavily.com/)\n\nSearch or ask...\n\nCtrl K\n\n- [Support](mailto:support@tavily.com)\n- [Get an API key](https://app.tavily.com)\n- [Get an API key](https://app.tavily.com)\n\nSearch...\n\nNavigation\n\n[Home](/welcome)[Documentation](/documentation/about)[SDKs](/sdk/python/quick-start)[Examples](/examples/use-cases/data-enrichment)[FAQ](/faq/faq)\n\nExplore our docs\n\nYour journey to state-of-the-art web search starts right here.\n\n[## Quickstart\n\nStart searching with Tavily in minutes](documentation/quickstart)[## API Reference\n\nStart using Tavily's powerful APIs](documentation/api-reference/endpoint/search)[## API Credits Overview\n\nLearn how to get and manage your Tavily API Credits](documentation/api-credits)[## Rate Limits\n\nLearn about Tavily's API rate limits for both development and production environments](documentation/rate-limits)[## Python\n\nGet started with our Python SDK, `tavily-python`](sdk/python/quick-start)[## Playground\n\nExplore Tavily's APIs with our interactive playground](https://app.tavily.com/playground)",
          "images": [],
          "favicon: "https://mintlify.s3-us-west-1.amazonaws.com/tavilyai/_generated/favicon/apple-touch-icon.png?v=3",
      requestId: "123e4567-e89b-12d3-a456-426614174111"
          
        }
      ]
    }
    ````
  </Accordion>
</AccordionGroup>

## Tavily Map

You can access Tavily Map in JavaScript through the client's `map` function.

### Parameters

| Parameter            | Type       | Description                                                                                                                                                                                                                                                        | Default |
| :------------------- | :--------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------ |
| `url` **(required)** | `string`   | The root URL to begin the mapping.                                                                                                                                                                                                                                 | —       |
| `maxDepth`           | `number`   | Max depth of the mapping. Defines how far from the base URL the crawler can explore.                                                                                                                                                                               | `1`     |
| `maxBreadth`         | `number`   | Max number of links to follow **per level** of the tree (i.e., per page).                                                                                                                                                                                          | `20`    |
| `limit`              | `number`   | Total number of links the crawler will process before stopping.                                                                                                                                                                                                    | `50`    |
| `instructions`       | `string`   | Natural language instructions for the mapper.                                                                                                                                                                                                                      | —       |
| `selectPaths`        | `string[]` | **Regex patterns** to select only URLs with specific path patterns (e.g., `"/docs/.*"`, `"/api/v1.*"`).                                                                                                                                                            | `[]`    |
| `selectDomains`      | `string[]` | **Regex patterns** to select crawling to specific domains or subdomains (e.g., `"^docs\.example\.com$"`).                                                                                                                                                          | `[]`    |
| `excludePaths`       | `string[]` | **Regex patterns** to exclude URLs with specific path patterns (e.g., `"/admin/.*"`, `"/private/.*"`).                                                                                                                                                             | `[]`    |
| `excludeDomains`     | `string[]` | **Regex patterns** to exclude specific domains or subdomains from mapping (e.g., `"^admin\.example\.com$"`).                                                                                                                                                       | `[]`    |
| `allowExternal`      | `boolean`  | Whether to return links from external domains in crawl output.                                                                                                                                                                                                     | `true`  |
| `timeout`            | `number`   | Maximum time in seconds to wait for the map operation before timing out. Must be between 10 and 150 seconds.                                                                                                                                                       | `150`   |
| `includeUsage`       | `boolean`  | Whether to include credit usage information in the response.`NOTE:`The value may be 0 if the total successful pages mapped has not yet reached 10 calls. See our [Credits & Pricing documentation](https://docs.tavily.com/documentation/api-credits) for details. | `false` |

### Response format

The response object you receive will be in the following format:

| Key            | Type       | Description                                                                                                    |
| :------------- | :--------- | :------------------------------------------------------------------------------------------------------------- |
| `baseUrl`      | `string`   | The URL you started the crawl from.                                                                            |
| `results`      | `string[]` | A list of URLs that were discovered during the mapping.                                                        |
| `responseTime` | `number`   | The crawl response time.                                                                                       |
| `requestId`    | `string`   | A unique request identifier you can share with customer support to help resolve issues with specific requests. |

### Example

<AccordionGroup>
  <Accordion title="Request">
    ```javascript theme={null}
    const { tavily } = require("@tavily/core");

    // Step 1. Instantiating your Tavily client
    const tvly = tavily({ apiKey: "tvly-YOUR_API_KEY" });

    // Step 2. Defining the starting URL of the mapping
    const url = "https://docs.tavily.com";

    // Step 3. Executing the mapping with some guidance parameters
    const response = await client.map(url, { instructions: "Find all pages on the Python SDK" });
      
    // Step 4. Printing the results
    console.log(response);
    ```
  </Accordion>

  <Accordion title="Response">
    ```javascript theme={null}
    {
        baseUrl: 'https://docs.tavily.com',
        results:[
          'https://docs.tavily.com/sdk/python/reference',
          'https://docs.tavily.com/sdk/python/quick-start',
          'https://docs.tavily.com/docs/python-sdk/tavily-search/getting-started'
        ],
        responseTime: 8.43
        requestId: "123e4567-e89b-12d3-a456-426614174111"
    }
    ```
  </Accordion>
</AccordionGroup>


# Quickstart
Source: https://docs.tavily.com/sdk/python/quick-start

Integrate Tavily's powerful APIs natively in your Python apps.

<Tip>
  Looking for the Python SDK Reference? Head to our [Python SDK Reference](/sdk/python/reference) and learn how to use `tavily-python`.
</Tip>

## Introduction

The Python SDK allows for easy interaction with the Tavily API, offering the full range of our search functionality directly from your Python programs. Easily integrate smart search capabilities into your applications, harnessing Tavily's powerful search features.

<CardGroup>
  <Card title="GitHub" icon="github" href="https://github.com/tavily-ai/tavily-python">
    `/tavily-ai/tavily-python`

    <img alt="GitHub Repo stars" />
  </Card>

  <Card title="PyPI" icon="python" href="https://pypi.org/project/tavily-python">
    `tavily-python`

    <img alt="PyPI downloads" />
  </Card>
</CardGroup>

## Quickstart

Get started with our Python SDK in less than 5 minutes!

<Card icon="key" href="https://app.tavily.com" title="Get your free API key">
  You get 1,000 free API Credits every month. **No credit card required.**
</Card>

### Installation

You can install the Tavily Python SDK using the following:

```bash theme={null}
pip install tavily-python
```

### Usage

With Tavily's Python SDK, you can search the web in only 4 lines of code:

```python theme={null}
from tavily import TavilyClient

tavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")
response = tavily_client.search("Who is Leo Messi?")

print(response)
```

You can also easily extract content from URLs:

```python theme={null}
from tavily import TavilyClient

tavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")
response = tavily_client.extract("https://en.wikipedia.org/wiki/Lionel_Messi")

print(response)
```

Tavily also allows you to perform a smart crawl starting at a given URL.

```python theme={null}
from tavily import TavilyClient

tavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")
response = tavily_client.crawl("https://docs.tavily.com", instructions="Find all pages on the Python SDK")

print(response)
```

These examples are very simple, and you can do so much more with Tavily!

## Features

Our Python SDK supports the full feature range of our [REST API](/documentation/api-reference/introduction), and more. We offer both a synchronous and an asynchronous client, for increased flexibility.

* The `search` function lets you harness the full power of Tavily Search.
* The `extract` function allows you to easily retrieve web content with Tavily Extract.
* The `crawl` and `map`functions allow you to intelligently traverse websites and extract content.

For more details, head to the [Python SDK Reference](/sdk/python/reference).


# SDK Reference
Source: https://docs.tavily.com/sdk/python/reference

Integrate Tavily's powerful APIs natively in your Python apps.

## Instantiating a client

To interact with Tavily in Python, you must instatiate a client with your API key. For greater flexibility, we provide both a synchronous and an asynchronous client class.

Once you have instantiated a client, call one of our supported methods (detailed below) to access the API.

### Synchronous Client

```python theme={null}
from tavily import TavilyClient

client = TavilyClient("tvly-YOUR_API_KEY")
```

### Asynchronous Client

```python theme={null}
from tavily import AsyncTavilyClient

client = AsyncTavilyClient("tvly-YOUR_API_KEY")
```

### Project Tracking

You can attach a Project ID to your client to organize and track API usage by project. This is useful when a single API key is used across multiple projects.

```python theme={null}
from tavily import TavilyClient

client = TavilyClient("tvly-YOUR_API_KEY", project_id="your-project-id")
```

Alternatively, you can set the `TAVILY_PROJECT` environment variable:

```python theme={null}
import os

os.environ["TAVILY_PROJECT"] = "your-project-id"

client = TavilyClient("tvly-YOUR_API_KEY")
```

All requests made with this client will include the Project ID, allowing you to filter by project in the /logs endpoint and platform usage dashboard.

### Session Tracking

You can attach session and user identifiers to your client for attribution and analytics across multi-step interactions and agent workflows. Each ID is sent as an HTTP header (`X-Session-Id`, `X-Human-Id`) on every request the client makes — across search, extract, crawl, map, and research.

```python theme={null}
from tavily import TavilyClient

client = TavilyClient(
  "tvly-YOUR_API_KEY",
  session_id="5874812a-2e9b-43ea-8978-6cc9225b587b",
  human_id="h_4f9ac",
)
```

You can also override either value on a per-call basis:

```python theme={null}
response = client.search(
  "Who is Leo Messi?",
  session_id="alt-session-id",
  human_id="alt-human-id",
)
```

For security, Tavily hashes human IDs before processing or storing them. See [Session Tracking](/documentation/api-reference/introduction#session--user-tracking) in the API reference for the underlying header contract.

### Proxies

If you would like to specify a proxy to be used when making requests, you can do so by passing in a proxy parameter on client instantiation.

Proxy configuration is available in both the synchronous and asynchronous clients.

```python theme={null}
from tavily import TavilyClient

proxies = {
  "http": "<your HTTP proxy>",
  "https": "<your HTTPS proxy>",
}

client = TavilyClient("tvly-YOUR_API_KEY", proxies=proxies)
```

Alternatively, you can specify which proxies to use by setting the `TAVILY_HTTP_PROXY` and `TAVILY_HTTPS_PROXY` variables in your environment file.

## Tavily Search

<Tip>
  **NEW!** Try our interactive [API
  Playground](https://app.tavily.com/playground) to see each parameter in
  action, and generate ready-to-use Python snippets.
</Tip>

You can access Tavily Search in Python through the client's `search` function.

### Parameters

| Parameter                    | Type            | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | Default     |   |
| :--------------------------- | :-------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------- | - |
| `query` **(required)**       | `str`           | The query to run a search on.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | —           |   |
| `auto_parameters`            | `bool`          | When `auto_parameters` is enabled, Tavily automatically configures search parameters based on your query's content and intent. You can still set other parameters manually, and your explicit values will override the automatic ones. The parameters `include_answer`, `include_raw_content`, and `max_results` must always be set manually, as they directly affect response size. Note: `search_depth` may be automatically set to advanced when it's likely to improve results. This uses 2 API credits per request. To avoid the extra cost, you can explicitly set `search_depth` to `basic`. | `"false"`   |   |
| `search_depth`               | `str`           | The depth of the search. It can be `"basic"` or `"advanced"`. `"advanced"` search is tailored to retrieve the most relevant sources and `content` snippets for your query, while `"basic"` search provides generic content snippets from each source.                                                                                                                                                                                                                                                                                                                                               | `"basic"`   |   |
| `topic`                      | `str`           | The category of the search. Determines which agent will be used. Supported values are `"general"`, `"news"` and `"finance"`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `"general"` |   |
| `time_range`                 | `str`           | The time range back from the current date based on publish date or last updated date. Accepted values include `"day"`, `"week"`, `"month"`, `"year"` or shorthand values `"d"`, `"w"`, `"m"`, `"y"`.                                                                                                                                                                                                                                                                                                                                                                                                | —           |   |
| `start_date`                 | `str`           | Will return all results after the specified start date based on publish date or last updated date. Required to be written in the format YYYY-MM-DD                                                                                                                                                                                                                                                                                                                                                                                                                                                  | —           |   |
| `end_date`                   | `str`           | Will return all results before the specified end date based on publish date or last updated date. Required to be written in the format YYYY-MM-DD.                                                                                                                                                                                                                                                                                                                                                                                                                                                  | —           |   |
| `max_results`                | `int`           | The maximum number of search results to return. It must be between `0` and `20`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `5`         |   |
| `chunks_per_source`          | `int`           | Chunks are short content snippets (maximum 500 characters each) pulled directly from the source. Use `chunks_per_source` to define the maximum number of relevant chunks returned per source and to control the `content` length. Chunks will appear in the `content` field as: `<chunk 1> [...] <chunk 2> [...] <chunk 3>`. Available only when `search_depth` is `"advanced"`.                                                                                                                                                                                                                    | `3`         |   |
| `include_images`             | `bool`          | Include images in the response. Returns both a top-level `images` list of query-related images and an `images` array inside each result object with images extracted from that specific source.                                                                                                                                                                                                                                                                                                                                                                                                     | `False`     |   |
| `include_image_descriptions` | `bool`          | Include a list of query-related images and their descriptions in the response.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `False`     |   |
| `include_answer`             | `bool` or `str` | Include an answer to the query generated by an LLM based on search results. A `"basic"` (or `True`) answer is quick but less detailed; an `"advanced"` answer is more detailed.                                                                                                                                                                                                                                                                                                                                                                                                                     | `False`     |   |
| `include_raw_content`        | `bool` or `str` | Include the cleaned and parsed HTML content of each search result. `"markdown"` or `True` returns search result content in markdown format. `"text"` returns the plain text from the results and may increase latency.                                                                                                                                                                                                                                                                                                                                                                              | `False`     |   |
| `include_domains`            | `list[str]`     | A list of domains to specifically include in the search results. Maximum 300 domains.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `[]`        |   |
| `exclude_domains`            | `list[str]`     | A list of domains to specifically exclude from the search results. Maximum 150 domains.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `[]`        |   |
| `country`                    | `str`           | Boost search results from a specific country. This will prioritize content from the selected country in the search results. Available only if topic is `general`.                                                                                                                                                                                                                                                                                                                                                                                                                                   | —           |   |
| `timeout`                    | `float`         | A timeout to be used in requests to the Tavily API.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `60`        |   |
| `exact_match`                | `bool`          | Ensure that only search results containing the exact quoted phrase(s) in your query are returned, bypassing synonyms or semantic variations. Wrap target phrases in quotes (e.g. `"John Smith"`). Punctuation is typically ignored inside quotes.                                                                                                                                                                                                                                                                                                                                                   | `False`     |   |
| `include_favicon`            | `bool`          | Whether to include the favicon URL for each result.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `False`     |   |
| `include_usage`              | `bool`          | Whether to include credit usage information in the response.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `False`     |   |

### Response format

The response object you receive will be in the following format:

| Key                 | Type                               | Description                                                                                                                                                                                                                                                                                                                                |
| :------------------ | :--------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `results`           | `list[Result]`                     | A list of sorted search results ranked by relevancy.                                                                                                                                                                                                                                                                                       |
| `query`             | `str`                              | Your search query.                                                                                                                                                                                                                                                                                                                         |
| `response_time`     | `float`                            | Your search result response time.                                                                                                                                                                                                                                                                                                          |
| `answer` (optional) | `str`                              | The answer to your search query, generated by an LLM based on Tavily's search results. This is only available if `include_answer` is set to `True`.                                                                                                                                                                                        |
| `images` (optional) | `list[str]` or `list[ImageResult]` | This is only available if `include_images` is set to `True`. A list of query-related image URLs. If `include_image_descriptions` is set to `True`, each entry will be an `ImageResult`. When `include_images` is `True`, each result in `results` will also contain its own `images` list with images extracted from that specific source. |
| `request_id`        | `str`                              | A unique request identifier you can share with customer support to help resolve issues with specific requests.                                                                                                                                                                                                                             |

### Results

| `Key`                       | `Type`                             | Description                                                                                                                                                                            |
| :-------------------------- | :--------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `title`                     | `str`                              | The title of the search result.                                                                                                                                                        |
| `url`                       | `str`                              | The URL of the search result.                                                                                                                                                          |
| `content`                   | `str`                              | The most query-related content from the scraped URL. Tavily uses proprietary AI to extract the most relevant content based on context quality and size.                                |
| `score`                     | `float`                            | The relevance score of the search result.                                                                                                                                              |
| `raw_content` (optional)    | `str`                              | The parsed and cleaned HTML content of the site. This is only available if `include_raw_content` is set to `True`.                                                                     |
| `published_date` (optional) | `str`                              | The publication date of the source. This is only available if the search `topic` is set to `"news"`.                                                                                   |
| `favicon` (optional)        | `str`                              | The favicon URL for the search result.                                                                                                                                                 |
| `images` (optional)         | `list[str]` or `list[ImageResult]` | Images extracted from this search result. Only included when `include_images` is set to `True`. If `include_image_descriptions` is set to `True`, each entry will be an `ImageResult`. |

#### Image Results

If `includeImageDescriptions` is set to `true`, each image in the `images` list will be in the following `ImageResult` format:

| Key           | Type     | Description                                |
| :------------ | :------- | :----------------------------------------- |
| `url`         | `string` | The URL of the image.                      |
| `description` | `string` | An LLM-generated description of the image. |

### Example

<AccordionGroup>
  <Accordion title="Request">
    ```python theme={null}
    from tavily import TavilyClient

    # Step 1. Instantiating your TavilyClient
    tavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")

    # Step 2. Executing the search request
    response = tavily_client.search("Who is Leo Messi?", include_images=True, include_image_descriptions=True)

    # Step 3. Printing the search results
    print(response)
    ```
  </Accordion>

  <Accordion title="Response">
    ```python theme={null}
    {
      "query": "Who is Leo Messi?",
      "images": [
        {
          "url": "Image 1 URL",
          "description": "Image 1 Description",
        },
        {
          "url": "Image 2 URL",
          "description": "Image 2 Description",
        },
        {
          "url": "Image 3 URL",
          "description": "Image 3 Description",
        },
        {
          "url": "Image 4 URL",
          "description": "Image 4 Description",
        },
        {
          "url": "Image 5 URL",
          "description": "Image 5 Description",
        }
      ],
      "results": [
        {
          "title": "Source 1 Title",
          "url": "Source 1 URL",
          "content": "Source 1 Content",
          "score": 0.99,
          "favicon": "https://example.com/favicon.ico",
          "images": [
            {
              "url": "Source 1 Image 1 URL",
              "description": "Source 1 Image 1 Description",
            },
            {
              "url": "Source 1 Image 2 URL",
              "description": "Source 1 Image 2 Description",
            }
          ]
        },
        {
          "title": "Source 2 Title",
          "url": "Source 2 URL",
          "content": "Source 2 Content",
          "score": 0.97,
          "favicon": "https://another.com/favicon.ico",
          "images": []
        }
      ],
      "response_time": 1.09,
      "request_id": "123e4567-e89b-12d3-a456-426614174111"
    }
    ```
  </Accordion>
</AccordionGroup>

### Exact Match Example

Use `exact_match` with quoted phrases in your query to find results containing a specific name or phrase verbatim:

```python theme={null}
from tavily import TavilyClient

client = TavilyClient(api_key="tvly-YOUR_API_KEY")

response = client.search(
    query='"John Smith" CEO Acme Corp',
    exact_match=True
)
```

## Tavily Extract

You can access Tavily Extract in Python through the client's `extract` function.

### Parameters

| Parameter             | Type                 | Description                                                                                                                                                                                                                                                                                                                                                                                            | Default      |   |
| :-------------------- | :------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------- | - |
| `urls` **(required)** | `str` or `list[str]` | The URL (or URLs) you want to extract. If a list is provided, it must not contain more than 20 URLs.                                                                                                                                                                                                                                                                                                   | —            |   |
| `include_images`      | `bool`               | Include a list of images extracted from the URLs in the response.                                                                                                                                                                                                                                                                                                                                      | `False`      |   |
| `extract_depth`       | `str`                | The depth of the extraction process. You may experience higher latency with `"advanced"` extraction, but it offers a higher success rate and retrieves more data from the URL (e.g., tables, embedded content). `"basic"` extraction costs 1 API Credit per 5 successful URL extractions, while `advanced` extraction costs 2 API Credits per 5 successful URL extractions.                            | `"basic"`    |   |
| `format`              | `str`                | The format of the extracted web page content. `"markdown"` returns content in markdown format. `"text"` returns plain text and may increase latency.                                                                                                                                                                                                                                                   | `"markdown"` |   |
| `timeout`             | `float`              | A timeout to be used in requests to the Tavily API.  Maximum time in seconds to wait for the URL extraction before timing out. Must be between 1.0 and 60.0 seconds. If not specified, default timeouts are applied based on extract\_depth: 10 seconds for basic extraction and 30 seconds for advanced extraction.                                                                                   | `None`       |   |
| `include_favicon`     | `bool`               | Whether to include the favicon URL for each result.                                                                                                                                                                                                                                                                                                                                                    | `False`      |   |
| `include_usage`       | `bool`               | Whether to include credit usage information in the response.`NOTE:`The value may be 0 if the total successful URL extractions has not yet reached 5 calls. See our [Credits & Pricing documentation](https://docs.tavily.com/documentation/api-credits) for details.                                                                                                                                   | `False`      |   |
| `query`               | `str`                | User intent for reranking extracted content chunks. When provided, chunks are reranked based on relevance to this query.                                                                                                                                                                                                                                                                               | `None`       |   |
| `chunks_per_source`   | `int`                | Chunks are short content snippets (maximum 500 characters each) pulled directly from the source. Use `chunks_per_source` to define the maximum number of relevant chunks returned per source and to control the `raw_content` length. Chunks will appear in the `raw_content` field as: `<chunk 1> [...] <chunk 2> [...] <chunk 3>`. Available only when `query` is provided. Must be between 1 and 5. | `3`          |   |

### Response format

The response object you receive will be in the following format:

| Key              | Type                     | Description                                                                                                    |
| :--------------- | :----------------------- | :------------------------------------------------------------------------------------------------------------- |
| `results`        | `list[SuccessfulResult]` | A list of extracted content.                                                                                   |
| `failed_results` | `list[FailedResult]`     | A list of URLs that could not be processed.                                                                    |
| `response_time`  | `float`                  | The search result response time.                                                                               |
| `request_id`     | `str`                    | A unique request identifier you can share with customer support to help resolve issues with specific requests. |

#### Successful Results

Each successful result in the `results` list will be in the following `SuccessfulResult` format:

| Key                  | Type        | Description                                                                                                      |
| :------------------- | :---------- | :--------------------------------------------------------------------------------------------------------------- |
| `url`                | `str`       | The URL of the webpage.                                                                                          |
| `raw_content`        | `str`       | The raw content extracted. When `query` is provided, contains the top-ranked chunks joined by `[...]` separator. |
| `images` (optional)  | `list[str]` | This is only available if `include_images` is set to `True`. A list of extracted image URLs.                     |
| `favicon` (optional) | `str`       | The favicon URL for the search result.                                                                           |

#### Failed Results

Each failed result in the `results` list will be in the following `FailedResult` format:

| Key     | Type  | Description                                                |
| :------ | :---- | :--------------------------------------------------------- |
| `url`   | `str` | The URL that failed.                                       |
| `error` | `str` | An error message describing why it could not be processed. |

### Example

<AccordionGroup>
  <Accordion title="Request">
    ```python theme={null}
    from tavily import TavilyClient

    # Step 1. Instantiating your TavilyClient
    tavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")

    # Step 2. Defining the list of URLs to extract content from
    urls = [
        "https://en.wikipedia.org/wiki/Artificial_intelligence",
        "https://en.wikipedia.org/wiki/Machine_learning",
        "https://en.wikipedia.org/wiki/Data_science",
    ]

    # Step 3. Executing the extract request
    response = tavily_client.extract(urls=urls, include_images=True)

    # Step 4. Printing the extracted raw content
    print(response)
    ```
  </Accordion>

  <Accordion title="Response">
    ```python theme={null}
    {
        "results": [
            {
                "url": "https://en.wikipedia.org/wiki/Artificial_intelligence",
                "raw_content": "URL 1 raw content",
                "images": [
                    "Image 1 URL",
                    "Image 2 URL"
                ],
                "favicon": "https://en.wikipedia.org/favicon.ico"
            },
            {
                "url": "https://en.wikipedia.org/wiki/Machine_learning",
                "raw_content": "URL 2 raw content",
                "images": [
                    "Image 3 URL",
                    "Image 4 URL"
                ],
                "favicon": "https://en.wikipedia.org/favicon.ico"
            }
        ],
        "failed_results": [],
        "response_time": 1.23,
        "request_id": "123e4567-e89b-12d3-a456-426614174111"
    }
    ```
  </Accordion>
</AccordionGroup>

## Tavily Crawl

You can access Tavily Crawl in Python through the `crawl` function.

### Parameters

| Parameter            | Type        | Description                                                                                                                                                                                                                                                                                                                                                   | Default      |
| :------------------- | :---------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :----------- |
| `url` **(required)** | `str`       | The root URL to begin the crawl.                                                                                                                                                                                                                                                                                                                              | —            |
| `max_depth`          | `int`       | Max depth of the crawl. Defines how far from the base URL the crawler can explore.                                                                                                                                                                                                                                                                            | `1`          |
| `max_breadth`        | `int`       | Max number of links to follow **per level** of the tree (i.e., per page).                                                                                                                                                                                                                                                                                     | `20`         |
| `limit`              | `int`       | Total number of links the crawler will process before stopping.                                                                                                                                                                                                                                                                                               | `50`         |
| `instructions`       | `str`       | Natural language instructions for the crawler.                                                                                                                                                                                                                                                                                                                | —            |
| `select_paths`       | `list[str]` | **Regex patterns** to select only URLs with specific path patterns (e.g., `"/docs/.*"`, `"/api/v1.*"`).                                                                                                                                                                                                                                                       | `None`       |
| `select_domains`     | `list[str]` | **Regex patterns** to select crawling to specific domains or subdomains (e.g., `"^docs\.example\.com$"`).                                                                                                                                                                                                                                                     | `None`       |
| `exclude_paths`      | `list[str]` | **Regex patterns** to exclude URLs with specific path patterns (e.g., `"/private/.*"`, `"/admin/.*"`).                                                                                                                                                                                                                                                        | `None`       |
| `exclude_domains`    | `list[str]` | **Regex patterns** to exclude specific domains or subdomains from crawling (e.g., `"^private\.example\.com$"`).                                                                                                                                                                                                                                               | `None`       |
| `allow_external`     | `bool`      | Whether to allow following links that go to external domains.                                                                                                                                                                                                                                                                                                 | `True`       |
| `include_images`     | `bool`      | Whether to extract image URLs from the crawled pages.                                                                                                                                                                                                                                                                                                         | `False`      |
| `extract_depth`      | `str`       | Advanced extraction retrieves more data, including tables and embedded content, with higher success but may increase latency. Options: `"basic"` or `"advanced"`.                                                                                                                                                                                             | `"basic"`    |
| `format`             | `str`       | The format of the extracted web page content. `markdown` returns content in markdown format. `text` returns plain text and may increase latency.                                                                                                                                                                                                              | `"markdown"` |
| `include_favicon`    | `bool`      | Whether to include the favicon URL for each result.                                                                                                                                                                                                                                                                                                           | `False`      |
| `timeout`            | `float`     | Maximum time in seconds to wait for the crawl operation before timing out. Must be between 10 and 150 seconds.                                                                                                                                                                                                                                                | `150`        |
| `include_usage`      | `bool`      | Whether to include credit usage information in the response.`NOTE:`The value may be 0 if the total use of /extract and /map have not yet reached minimum requirements. See our [Credits & Pricing documentation](https://docs.tavily.com/documentation/api-credits) for details.                                                                              | `False`      |
| `chunks_per_source`  | `int`       | Chunks are short content snippets (maximum 500 characters each) pulled directly from the source. Use `chunks_per_source` to define the maximum number of relevant chunks returned per source and to control the `raw_content` length. Chunks will appear in the `raw_content` field as: `<chunk 1> [...] <chunk 2> [...] <chunk 3>`. Must be between 1 and 5. | `3`          |

### Response format

The response object you receive will be in the following format:

| Key             | Type           | Description                                                                                                    |
| :-------------- | :------------- | :------------------------------------------------------------------------------------------------------------- |
| `base_url`      | `str`          | The URL you started the crawl from.                                                                            |
| `results`       | `list[Result]` | A list of crawled pages.                                                                                       |
| `response_time` | `float`        | The crawl response time.                                                                                       |
| `request_id`    | `str`          | A unique request identifier you can share with customer support to help resolve issues with specific requests. |

#### Results

Each successful result in the `results` list will be in the following `Result` format:

| Key                  | Type        | Description                            |
| :------------------- | :---------- | :------------------------------------- |
| `url`                | `str`       | The URL of the webpage.                |
| `raw_content`        | `str`       | The raw content extracted.             |
| `images`             | `list[str]` | Image URLs extracted from the page.    |
| `favicon` (optional) | `str`       | The favicon URL for the search result. |

### Example

<AccordionGroup>
  <Accordion title="Request">
    ```python theme={null}
    from tavily import TavilyClient

    # Step 1. Instantiating your TavilyClient
    tavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")

    # Step 2. Defining the starting URL of the crawl
    url = "https://docs.tavily.com"

    # Step 3. Executing the crawl with some guidance parameters
    response = tavily_client.crawl(url, instructions="Find information on the Python SDK")

    # Step 4. Printing the crawled results
    print(response)
    ```
  </Accordion>

  <Accordion title="Response">
    ````python theme={null}
    {
        "base_url": "https://docs.tavily.com",
        "results": [
            {
                "url": "https://docs.tavily.com/sdk/python/quick-start",
                "raw_content": "Quickstart - Tavily Docs\n\n[Tavily Docs home page![light logo](https://mintlify.s3.us-west-1.amazonaws.com/tavilyai/logo/light.svg)![dark logo](https://mintlify.s3.us-west-1.amazonaws.com/tavilyai/logo/dark.svg)](https://tavily.com/)\n\nSearch or ask...\n\nCtrl K\n\n- [Support](mailto:support@tavily.com)\n- [Get an API key](https://app.tavily.com)\n- [Get an API key](https://app.tavily.com)\n\nSearch...\n\nNavigation\n\nPython\n\nQuickstart\n\n[Home](/welcome)[Documentation](/documentation/about)[SDKs](/sdk/python/quick-start)[Examples](/examples/use-cases/data-enrichment)[FAQ](/faq/faq)\n\n- [API Playground](https://app.tavily.com/playground)\n- [Community](https://community.tavily.com)\n- [Blog](https://blog.tavily.com)\n\n##### Python\n\n- [Quickstart](/sdk/python/quick-start)\n- [SDK Reference](/sdk/python/reference)\n\n##### JavaScript\n\n- [Quickstart](/sdk/javascript/quick-start)\n- [SDK Reference](/sdk/javascript/reference)\n\nPython\n\n# Quickstart\n\nIntegrate Tavily\u2019s powerful APIs natively in your Python apps.\n\nLooking for the Python SDK Reference? Head to our [Python SDK Reference](/sdk/python/reference) and learn how to use `tavily-python`.\n\n## [\u200b](#introduction) Introduction\n\nThe Python SDK allows for easy interaction with the Tavily API, offering the full range of our search functionality directly from your Python programs. Easily integrate smart search capabilities into your applications, harnessing Tavily\u2019s powerful search features.\n\n[## GitHub\n\n`/tavily-ai/tavily-python`\n\n![GitHub Repo stars](https://img.shields.io/github/stars/tavily-ai/tavily-python?style=social)](https://github.com/tavily-ai/tavily-python)[## PyPI\n\n`tavily-python`\n\n![PyPI downloads](https://img.shields.io/pypi/dm/tavily-python)](https://pypi.org/project/tavily-python)\n\n## [\u200b](#quickstart) Quickstart\n\nGet started with our Python SDK in less than 5 minutes!\n\n[## Get your free API key\n\nYou get 1,000 free API Credits every month. **No credit card required.**](https://app.tavily.com)\n\n### [\u200b](#installation) Installation\n\nYou can install the Tavily Python SDK using the following:\n\nCopy\n\n```\npip install tavily-python\n\n```\n\n### [\u200b](#usage) Usage\n\nWith Tavily\u2019s Python SDK, you can search the web in only 4 lines of code:\n\nCopy\n\n```\nfrom tavily import TavilyClient\n\ntavily_client = TavilyClient(api_key=\"tvly-YOUR_API_KEY\")\nresponse = tavily_client.search(\"Who is Leo Messi?\")\n\nprint(response)\n\n```\n\nYou can also easily extract content from URLs:\n\nCopy\n\n```\nfrom tavily import TavilyClient\n\ntavily_client = TavilyClient(api_key=\"tvly-YOUR_API_KEY\")\nresponse = tavily_client.extract(\"https://en.wikipedia.org/wiki/Lionel_Messi\")\n\nprint(response)\n\n```\n\nTavily also allows you to perform a smart crawl starting at a given URL.\n\nCopy\n\n```\nfrom tavily import TavilyClient\n\ntavily_client = TavilyClient(api_key=\"tvly-YOUR_API_KEY\")\nresponse = tavily_client.crawl(\"https://docs.tavily.com\", query=\"Python SDK\")\n\nprint(response)\n\n```\n\nThese examples are very simple, and you can do so much more with Tavily!\n\n## [\u200b](#features) Features\n\nOur Python SDK supports the full feature range of our [REST API](/api-reference), and more. We offer both a synchronous and an asynchronous client, for increased flexibility.\n\n- The `search` function lets you harness the full power of Tavily Search.\n- The `extract` function allows you to easily retrieve web content with Tavily Extract.\n\nFor more details, head to the [Python SDK Reference](/sdk/python/reference).\n\n[SDK Reference](/sdk/python/reference)\n\n[x](https://x.com/tavilyai)[github](https://github.com/tavily-ai)[linkedin](https://linkedin.com/company/tavily)[website](https://tavily.com)\n\n[Powered by Mintlify](https://mintlify.com/preview-request?utm_campaign=poweredBy&utm_medium=docs&utm_source=docs.tavily.com)\n\nOn this page\n\n- [Introduction](#introduction)\n- [Quickstart](#quickstart)\n- [Installation](#installation)\n- [Usage](#usage)\n- [Features]\n        }\n    ],\n    'response_time': 9.14\n}\n\n```\n\n## [\u200b](#tavily-map) Tavily Map\n\nTavily Map allows you to obtain a sitemap starting from a base URL.\n\nYou can access Tavily Map in Python through the `map` function.\n\n### [\u200b](#parameters-4) Parameters\n\n| Parameter | Type | Description | Default |\n| --- | --- | --- | --- |\n| `url` **(required)** | `str` | The root URL to begin the mapping. | \u2014 |\n| `max_depth` | `int` | Max depth of the mapping. Defines how far from the base URL the crawler can explore. | `1` |\n| `max_breadth` | `int` | Max number of links to follow **per level** of the tree (i.e., per page). | `20` |\n| `limit` | `int` | Total number of links the crawler will process before stopping. | `50` |\n| `query` | `str` | Natural language instructions for the crawler | \u2014 |\n| `select_paths` | `list[str]` | **Regex patterns** to select only URLs with specific path patterns (e.g., `\"/docs/.*\"`, `\"/api/v1.*\"`). | `None` |\n| `select_domains` | `list[str]` | **Regex patterns** to select crawling to specific domains or subdomains (e.g., `\"^docs\\.example\\.com$\"`). | `None` |\n| `exclude_paths` | `list[str]` | **Regex patterns** to exclude URLs with specific path patterns (e.g., `\"/private/.*\"`, `\"/admin/.*\"`). | `None` |\n| `exclude_domains` | `list[str]` | **Regex patterns** to exclude specific domains or subdomains from crawling (e.g., `\"^private\\.example\\.com$\"`). | `None` |\n| `allow_external` | `bool` | Whether to allow following links that go to external domains. | `False` |\n\n### [\u200b](#response-format-4) Response format\n\nThe response object you receive will be in the following format:\n\n| Key | Type | Description |\n| --- | --- | --- |\n| `base_url` | `str` | The URL you started the mapping from. |\n| `results` | `list[str]` | A list of URLs that were discovered during the mapping. |\n| `response_time` | `float` | The mapping response time. |\n\n### [\u200b](#example-4) Example\n\nRequest\n\nCopy\n\n```\nfrom tavily import TavilyClient\n\n# Step 1. Instantiating your TavilyClient\ntavily_client = TavilyClient(api_key=\"tvly-YOUR_API_KEY\")\n\n# Step 2. Defining the starting URL of the mapping\nurl = \"https://docs.tavily.com\"\n\n# Step 3. Executing the mapping with some guidance parameters\nresponse = tavily_client.mapping(url, query=\"JavaScript\")\n\n# Step 4. Printing the results\nprint(response)\n\n```\n\nResponse\n\nCopy\n\n```\n{\n    'base_url': 'https://docs.tavily.com',\n    'results': [\n      'https://docs.tavily.com/sdk/javascript/quick-start',\n      'https://docs.tavily.com/sdk/javascript/reference',\n    ],\n    'response_time': 8.43\n}\n\n```\n\n## [\u200b](#tavily-hybrid-rag) Tavily Hybrid RAG\n\nTavily Hybrid RAG is an extension of the Tavily Search API built to retrieve relevant data from both the web and an existing database collection. This way, a RAG agent can combine web sources and locally available data to perform its tasks. Additionally, data queried from the web that is not yet in the database can optionally be inserted into it. This will allow similar searches in the future to be answered faster, without the need to query the web again.\n\n### [\u200b](#parameters-5) Parameters\n\nThe TavilyHybridClient class is your gateway to Tavily Hybrid RAG. There are a few important parameters to keep in mind when you are instantiating a Tavily Hybrid Client.\n\n| Parameter | Type | Description | Default |\n| --- | --- | --- | --- |\n| `api_key` | `str` | Your Tavily API Key |  |\n| `db_provider` | `str` | Your database provider. Currently, only `\"mongodb\"` is supported. |  |\n| `collection` | `str` | A reference to the MongoDB collection that will be used for local search. |  |\n| `embeddings_field` (optional) | `str` | The name of the field that stores the embeddings in the specified collection. This field MUST be the same one used in the specified index. This will also be used when inserting web search results in the database using our default function. | `\"embeddings\"` |\n| `content_field` (optional) | `str` | The name of the field that stores the text content in the specified collection. This will also be used when inserting web search results in the database using our default function. | `\"content\"` |\n| `embedding_function` (optional) | `function` | A custom embedding function (if you want to use one). The function must take in a `list[str]` corresponding to the list of strings to be embedded, as well as an additional string defining the type of document. It must return a `list[list[float]]`, one embedding per input string. If no function is provided, defaults to Cohere\u2019s Embed. Keep in mind that you shouldn\u2019t mix different embeddings in the same database collection. |  |\n| `ranking_function` (optional) | `function` | A custom ranking function (if you want to use one). If no function is provided, defaults to Cohere\u2019s Rerank. It should return an ordered `list[dict]` where the documents are sorted by decreasing relevancy to your query. Each returned document will have two properties - `content`, which is a `str`, and `score`, which is a `float`. The function MUST accept the following parameters: `query`: `str` - This is the query you are executing. When your ranking function is called during Hybrid RAG, the query parameter of your search call (more details below) will be passed as query. `documents`:`List[Dict]`: - This is the list of documents that are returned by your Hybrid RAG call and that you want to sort. Each document will have two properties - `content`, which is a `str`, and `score`, which is a `float`. `top_n`: `int` - This is the number of results you want to return after ranking. When your ranking function is called during Hybrid RAG, the max\\_results value will be passed as `top_n`. |  |\n\n### [\u200b](#methods) Methods\n\n`search`(query, max\\_results=10, max\\_local=None, max\\_foreign=None, save\\_foreign=False, \\*\\*kwargs)\n\nPerforms a Tavily Hybrid RAG query and returns the retrieved documents as a `list[dict]` where the documents are sorted by decreasing relevancy to your query. Each returned document will have three properties - `content` (str), `score` (float), and `origin`, which is either `local` or `foreign`.\n\n| Parameter | Type | Description | Default |  |\n| --- | --- | --- | --- | --- |\n| `query` | `str` | The query you want to search for. |  |  |\n| `max_results` | `int` | The maximum number of total search results to return. | 10 |  |\n| `max_local` | `int` | The maximum number of local search results to return. | `None`, which defaults to `max_results`. |  |\n| `max_local` | `int` | The maximum number of local search results to return. | `None`, which defaults to `max_results`. |  |\n| `max_foreign` | `int` | The maximum number of web search results to return. | `None`, which defaults to `max_results`. |  |\n| `save_foreign` | `Union[bool, function]` | Save documents from the web search in the local database. If `True` is passed, our default saving function (which only saves the content `str` and the embedding `list[float]` will be used.) If `False` is passed, no web search result documents will be saved in the local database. If a function is passed, that function MUST take in a `dict` as a parameter, and return another `dict`. The input `dict` contains all properties of the returned Tavily result object. The output dict is the final document that will be inserted in the database. You are free to add to it any fields that are supported by the database, as well as remove any of the default ones. If this function returns `None`, the document will not be saved in the database. |  |  |\n\nAdditional parameters can be provided as keyword arguments (detailed below). The keyword arguments supported by this method are: `search_depth`, `topic`, `include_raw_content`, `include_domains`,`exclude_domains`.\n\n### [\u200b](#setup) Setup\n\n#### [\u200b](#mongodb-setup) MongoDB setup\n\nYou will need to have a MongoDB collection with a vector search index. You can follow the [MongoDB Documentation](https://www.mongodb.com/docs/atlas/atlas-vector-search/vector-search-type/) to learn how to set this up.\n\n#### [\u200b](#cohere-api-key) Cohere API Key\n\nBy default, embedding and ranking use the Cohere API, our recommended option. Unless you want to provide a custom embedding and ranking function, you\u2019ll need to get an API key from [Cohere](https://cohere.com/) and set it as an environment variable named `CO_API_KEY`\n\nIf you decide to stick with Cohere, please note that you\u2019ll need to install the Cohere Python package as well:\n\nCopy\n\n```\npip install cohere\n\n```\n\n#### [\u200b](#tavily-hybrid-rag-client-setup) Tavily Hybrid RAG Client setup\n\nOnce you are done setting up your database, you\u2019ll need to create a MongoDB Client as well as a Tavily Hybrid RAG Client.\nA minimal setup would look like this:\n\nCopy\n\n```\nfrom pymongo import MongoClient\nfrom tavily import TavilyHybridClient\n\ndb = MongoClient(\"mongodb+srv://YOUR_MONGO_URI\")[\"YOUR_DB\"]\n\nhybrid_rag = TavilyHybridClient(\n    api_key=\"tvly-YOUR_API_KEY\",\n    db_provider=\"mongodb\",\n    collection=db.get_collection(\"YOUR_COLLECTION\"),\n    index=\"YOUR_VECTOR_SEARCH_INDEX\",\n    embeddings_field=\"YOUR_EMBEDDINGS_FIELD\",\n    content_field=\"YOUR_CONTENT_FIELD\"\n)\n\n```\n\n### [\u200b](#usage) Usage\n\nOnce you create the proper clients, you can easily start searching. A few simple examples are shown below. They assume you\u2019ve followed earlier steps. You can use most of the Tavily Search parameters with Tavily Hybrid RAG as well.\n\n#### [\u200b](#simple-tavily-hybrid-rag-example) Simple Tavily Hybrid RAG example\n\nThis example will look for context about Leo Messi on the web and in the local database.\nHere, we get 5 sources, both from our database and from the web, but we want to exclude unwanted-domain.com from our web search results:\n\nCopy\n\n```\nresults = hybrid_rag.search(\"Who is Leo Messi?\", max_results=5, exclude_domains=['unwanted-domain.com'])\n\n```\n\nHere, we want to prioritize the number of local sources, so we will get 2 foreign (web) sources, and 5 sources from our database:\n\nCopy\n\n```\nresults = hybrid_rag.search(\"Who is Leo Messi?\",  max_local=5, max_foreign=2)\n\n```\n\nNote: The sum of `max_local` and `max_foreign` can exceed `max_results`, but only the top `max_results` results will be returned.\n\n#### [\u200b](#adding-retrieved-data-to-the-database) Adding retrieved data to the database\n\nIf you want to add the retrieved data to the database, you can do so by setting the save\\_foreign parameter to True:\n\nCopy\n\n```\nresults = hybrid_rag.search(\"Who is Leo Messi?\", save_foreign=True)\n\n```\n\nThis will use our default saving function, which stores the content and its embedding.\n\n### [\u200b](#examples) Examples\n\n#### [\u200b](#sample-1%3A-using-a-custom-saving-function) Sample 1: Using a custom saving function\n\nYou might want to add some extra properties to documents you\u2019re inserting or even discard some of them based on custom criteria. This can be done by passing a function to the save\\_foreign parameter:\n\nCopy\n\n```\ndef save_document(document):\n    if document['score'] < 0.5:\n        return None # Do not save documents with low scores\n\n    return {\n        'content': document['content'],\n\n         # Save the title and URL in the database\n        'site_title': document['title'],\n        'site_url': document['url'],\n\n        # Add a new field\n        'added_at': datetime.now()\n    }\n\nresults = hybrid_rag.search(\"Who is Leo Messi?\", save_foreign=save_document)\n\n```\n\n#### [\u200b](#sample-2%3A-using-a-custom-embedding-function) Sample 2: Using a custom embedding function\n\nBy default, we use [Cohere](https://cohere.com/) for our embeddings. If you want to use your own embeddings, can pass a custom embedding function to the TavilyHybridClient:\n\nCopy\n\n```\ndef my_embedding_function(texts, doc_type): # doc_type will be either 'search_query' or 'search_document'\n    return my_embedding_model.encode(texts)\n\nhybrid_rag = TavilyHybridClient(\n    # ...\n    embedding_function=my_embedding_function\n)\n\n```\n\n#### [\u200b](#sample-3%3A-using-a-custom-ranking-function) Sample 3: Using a custom ranking function\n\nCohere\u2019s [rerank](https://cohere.com/rerank) model is used by default, but you can pass your own function to the ranking\\_function parameter:\n\nCopy\n\n```\ndef my_ranking_function(query, documents, top_n):\n    return my_ranking_model.rank(query, documents, top_n)\n\nhybrid_rag = TavilyHybridClient(\n    # ...\n    ranking_function=my_ranking_function\n)\n\n```\n\n[Quickstart](/sdk/python/quick-start)[Quickstart](/sdk/javascript/quick-start)\n\n[x](https://x.com/tavilyai)[github](https://github.com/tavily-ai)[linkedin](https://linkedin.com/company/tavily)[website](https://tavily.com)\n\n[Powered by Mintlify](https://mintlify.com/preview-request?utm_campaign=poweredBy&utm_medium=docs&utm_source=docs.tavily.com)\n\nOn this page\n\n- [Instantiating a client](#instantiating-a-client)\n- [Synchronous Client](#synchronous-client)\n- [Asynchronous Client](#asynchronous-client)\n- [Proxies](#proxies)\n- [Tavily Search](#tavily-search)\n- [Parameters](#parameters)\n- [Response format](#response-format)\n- [Results](#results)\n- [Image Results](#image-results)\n- [Example](#example)\n- [Tavily Extract](#tavily-extract)\n- [Parameters](#parameters-2)\n- [Response format](#response-format-2)\n- [Successful Results](#successful-results)\n- [Failed Results](#failed-results)\n- [Example](#example-2)\n- [Tavily Crawl](#tavily-crawl)\n- [Parameters](#parameters-3)\n- [Response format](#response-format-3)\n- [Results](#results-2)\n- [Example](#example-3)\n- [Tavily Map](#tavily-map)\n- [Parameters](#parameters-4)\n- [Response format](#response-format-4)\n- [Example](#example-4)\n- [Tavily Hybrid RAG](#tavily-hybrid-rag)\n- [Parameters](#parameters-5)\n- [Methods](#methods)\n- [Setup](#setup)\n- [MongoDB setup](#mongodb-setup)\n- [Cohere API Key](#cohere-api-key)\n- [Tavily Hybrid RAG Client setup](#tavily-hybrid-rag-client-setup)\n- [Usage](#usage)\n- [Simple Tavily Hybrid RAG example](#simple-tavily-hybrid-rag-example)\n- [Adding retrieved data to the database](#adding-retrieved-data-to-the-database)\n- [Examples](#examples)\n- [Sample 1: Using a custom saving function](#sample-1%3A-using-a-custom-saving-function)\n- [Sample 2: Using a custom embedding function](#sample-2%3A-using-a-custom-embedding-function)\n- [Sample 3: Using a custom ranking function](#sample-3%3A-using-a-custom-ranking-function)",
                "images": [],
                "favicon": "https://mintlify.s3-us-west-1.amazonaws.com/tavilyai/_generated/favicon/apple-touch-icon.png?v=3"

            }
        ],
        "response_time": 9.07,
        "request_id": "123e4567-e89b-12d3-a456-426614174111"
    }
    ````
  </Accordion>
</AccordionGroup>

## Tavily Map

Tavily Map allows you to obtain a sitemap starting from a base URL.

You can access Tavily Map in Python through the `map` function.

### Parameters

| Parameter            | Type        | Description                                                                                                                                                                                                                                                        | Default |
| :------------------- | :---------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------ |
| `url` **(required)** | `str`       | The root URL to begin the mapping.                                                                                                                                                                                                                                 | —       |
| `max_depth`          | `int`       | Max depth of the mapping. Defines how far from the base URL the crawler can explore.                                                                                                                                                                               | `1`     |
| `max_breadth`        | `int`       | Max number of links to follow **per level** of the tree (i.e., per page).                                                                                                                                                                                          | `20`    |
| `limit`              | `int`       | Total number of links the crawler will process before stopping.                                                                                                                                                                                                    | `50`    |
| `instructions`       | `str`       | Natural language instructions for the crawler                                                                                                                                                                                                                      | —       |
| `select_paths`       | `list[str]` | **Regex patterns** to select only URLs with specific path patterns (e.g., `"/docs/.*"`, `"/api/v1.*"`).                                                                                                                                                            | `None`  |
| `select_domains`     | `list[str]` | **Regex patterns** to select crawling to specific domains or subdomains (e.g., `"^docs\.example\.com$"`).                                                                                                                                                          | `None`  |
| `exclude_paths`      | `list[str]` | **Regex patterns** to exclude URLs with specific path patterns (e.g., `"/private/.*"`, `"/admin/.*"`).                                                                                                                                                             | `None`  |
| `exclude_domains`    | `list[str]` | **Regex patterns** to exclude specific domains or subdomains from crawling (e.g., `"^private\.example\.com$"`).                                                                                                                                                    | `None`  |
| `allow_external`     | `bool`      | Whether to allow following links that go to external domains.                                                                                                                                                                                                      | `True`  |
| `timeout`            | `float`     | Maximum time in seconds to wait for the map operation before timing out. Must be between 10 and 150 seconds.                                                                                                                                                       | `150`   |
| `include_usage`      | `bool`      | Whether to include credit usage information in the response.`NOTE:`The value may be 0 if the total successful pages mapped has not yet reached 10 calls. See our [Credits & Pricing documentation](https://docs.tavily.com/documentation/api-credits) for details. | `False` |

### Response format

The response object you receive will be in the following format:

| Key             | Type        | Description                                                                                                   |
| :-------------- | :---------- | :------------------------------------------------------------------------------------------------------------ |
| `base_url`      | `str`       | The URL you started the mapping from.                                                                         |
| `results`       | `list[str]` | A list of URLs that were discovered during the mapping.                                                       |
| `response_time` | `float`     | The mapping response time.                                                                                    |
| `request_id`    | `str`       | A unique request identifier you can share with customer support to help resolve issues with specific requests |

### Example

<AccordionGroup>
  <Accordion title="Request">
    ```python theme={null}
    from tavily import TavilyClient

    # Step 1. Instantiating your TavilyClient
    tavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")

    # Step 2. Defining the starting URL of the mapping
    url = "https://docs.tavily.com"

    # Step 3. Executing the mapping with some guidance parameters
    response = tavily_client.mapping(url, instructions="Find information on the JavaScript SDK")

    # Step 4. Printing the results
    print(response)
    ```
  </Accordion>

  <Accordion title="Response">
    ```python theme={null}
    {
        'base_url': 'https://docs.tavily.com',
        'results': [
          'https://docs.tavily.com/sdk/javascript/quick-start',
          'https://docs.tavily.com/sdk/javascript/reference',
        ],
        'response_time': 8.43,
        "request_id": "123e4567-e89b-12d3-a456-426614174111"
    }
    ```
  </Accordion>
</AccordionGroup>

## Tavily Hybrid RAG

Tavily Hybrid RAG is an extension of the Tavily Search API built to retrieve relevant data from both the web and an existing database collection. This way, a RAG agent can combine web sources and locally available data to perform its tasks. Additionally, data queried from the web that is not yet in the database can optionally be inserted into it. This will allow similar searches in the future to be answered faster, without the need to query the web again.

### Parameters

The TavilyHybridClient class is your gateway to Tavily Hybrid RAG. There are a few important parameters to keep in mind when you are instantiating a Tavily Hybrid Client.

| Parameter                       | Type       | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | Default        |
| :------------------------------ | :--------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------- |
| `api_key`                       | `str`      | Your Tavily API Key                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                |
| `db_provider`                   | `str`      | Your database provider. Currently, only `"mongodb"` is supported.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                |
| `collection`                    | `str`      | A reference to the MongoDB collection that will be used for local search.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                |
| `embeddings_field` (optional)   | `str`      | The name of the field that stores the embeddings in the specified collection. This field MUST be the same one used in the specified index. This will also be used when inserting web search results in the database using our default function.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `"embeddings"` |
| `content_field` (optional)      | `str`      | The name of the field that stores the text content in the specified collection. This will also be used when inserting web search results in the database using our default function.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `"content"`    |
| `embedding_function` (optional) | `function` | A custom embedding function (if you want to use one). The function must take in a `list[str]` corresponding to the list of strings to be embedded, as well as an additional string defining the type of document. It must return a `list[list[float]]`, one embedding per input string. If no function is provided, defaults to Cohere's Embed. Keep in mind that you shouldn't mix different embeddings in the same database collection.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                |
| `ranking_function` (optional)   | `function` | A custom ranking function (if you want to use one). If no function is provided, defaults to Cohere's Rerank. It should return an ordered `list[dict]` where the documents are sorted by decreasing relevancy to your query. Each returned document will have two properties - `content`, which is a `str`, and `score`, which is a `float`. The function MUST accept the following parameters: `query`: `str` - This is the query you are executing. When your ranking function is called during Hybrid RAG, the query parameter of your search call (more details below) will be passed as query. `documents`:`List[Dict]`: - This is the list of documents that are returned by your Hybrid RAG call and that you want to sort. Each document will have two properties - `content`, which is a `str`, and `score`, which is a `float`. `top_n`: `int` - This is the number of results you want to return after ranking. When your ranking function is called during Hybrid RAG, the max\_results value will be passed as `top_n`. |                |

### Methods

`search`(query, max\_results=10, max\_local=None, max\_foreign=None, save\_foreign=False, \*\*kwargs)

Performs a Tavily Hybrid RAG query and returns the retrieved documents as a `list[dict]` where the documents are sorted by decreasing relevancy to your query. Each returned document will have three properties - `content` (str), `score` (float), and `origin`, which is either `local` or `foreign`.

| Parameter      | Type                    | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Default                                  |   |
| :------------- | :---------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------- | - |
| `query`        | `str`                   | The query you want to search for.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | —                                        |   |
| `max_results`  | `int`                   | The maximum number of total search results to return.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 10                                       |   |
| `max_local`    | `int`                   | The maximum number of local search results to return.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `None`, which defaults to `max_results`. |   |
| `max_local`    | `int`                   | The maximum number of local search results to return.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `None`, which defaults to `max_results`. |   |
| `max_foreign`  | `int`                   | The maximum number of web search results to return.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `None`, which defaults to `max_results`. |   |
| `save_foreign` | `Union[bool, function]` | Save documents from the web search in the local database. If `True` is passed, our default saving function (which only saves the content `str` and the embedding `list[float]` will be used.) If `False` is passed, no web search result documents will be saved in the local database. If a function is passed, that function MUST take in a `dict` as a parameter, and return another `dict`. The input `dict` contains all properties of the returned Tavily result object. The output dict is the final document that will be inserted in the database. You are free to add to it any fields that are supported by the database, as well as remove any of the default ones. If this function returns `None`, the document will not be saved in the database. | —                                        |   |

Additional parameters can be provided as keyword arguments (detailed below). The keyword arguments supported by this method are: `search_depth`, `topic`, `include_raw_content`, `include_domains`,`exclude_domains`.

### Setup

#### MongoDB setup

You will need to have a MongoDB collection with a vector search index. You can follow the [MongoDB Documentation](https://www.mongodb.com/docs/atlas/atlas-vector-search/vector-search-type/) to learn how to set this up.

#### Cohere API Key

By default, embedding and ranking use the Cohere API, our recommended option. Unless you want to provide a custom embedding and ranking function, you'll need to get an API key from [Cohere](https://cohere.com/) and set it as an environment variable named `CO_API_KEY`

If you decide to stick with Cohere, please note that you'll need to install the Cohere Python package as well:

```bash theme={null}
pip install cohere
```

#### Tavily Hybrid RAG Client setup

Once you are done setting up your database, you'll need to create a MongoDB Client as well as a Tavily Hybrid RAG Client.
A minimal setup would look like this:

```python theme={null}
from pymongo import MongoClient
from tavily import TavilyHybridClient

db = MongoClient("mongodb+srv://YOUR_MONGO_URI")["YOUR_DB"]

hybrid_rag = TavilyHybridClient(
    api_key="tvly-YOUR_API_KEY",
    db_provider="mongodb",
    collection=db.get_collection("YOUR_COLLECTION"),
    index="YOUR_VECTOR_SEARCH_INDEX",
    embeddings_field="YOUR_EMBEDDINGS_FIELD",
    content_field="YOUR_CONTENT_FIELD"
)
```

### Usage

Once you create the proper clients, you can easily start searching. A few simple examples are shown below. They assume you've followed earlier steps. You can use most of the Tavily Search parameters with Tavily Hybrid RAG as well.

#### Simple Tavily Hybrid RAG example

This example will look for context about Leo Messi on the web and in the local database.
Here, we get 5 sources, both from our database and from the web, but we want to exclude unwanted-domain.com from our web search results:

```python theme={null}
results = hybrid_rag.search("Who is Leo Messi?", max_results=5, exclude_domains=['unwanted-domain.com'])
```

Here, we want to prioritize the number of local sources, so we will get 2 foreign (web) sources, and 5 sources from our database:

```python theme={null}
results = hybrid_rag.search("Who is Leo Messi?",  max_local=5, max_foreign=2)
```

Note: The sum of `max_local` and `max_foreign` can exceed `max_results`, but only the top `max_results` results will be returned.

#### Adding retrieved data to the database

If you want to add the retrieved data to the database, you can do so by setting the save\_foreign parameter to True:

```python theme={null}
results = hybrid_rag.search("Who is Leo Messi?", save_foreign=True)
```

This will use our default saving function, which stores the content and its embedding.

### Examples

#### Sample 1: Using a custom saving function

You might want to add some extra properties to documents you're inserting or even discard some of them based on custom criteria. This can be done by passing a function to the save\_foreign parameter:

```python theme={null}
def save_document(document):
    if document['score'] < 0.5:
        return None # Do not save documents with low scores

    return {
        'content': document['content'],

         # Save the title and URL in the database
        'site_title': document['title'],
        'site_url': document['url'],

        # Add a new field
        'added_at': datetime.now()
    }

results = hybrid_rag.search("Who is Leo Messi?", save_foreign=save_document)
```

#### Sample 2: Using a custom embedding function

By default, we use [Cohere](https://cohere.com/) for our embeddings. If you want to use your own embeddings, can pass a custom embedding function to the TavilyHybridClient:

```python theme={null}
def my_embedding_function(texts, doc_type): # doc_type will be either 'search_query' or 'search_document'
    return my_embedding_model.encode(texts)

hybrid_rag = TavilyHybridClient(
    # ...
    embedding_function=my_embedding_function
)
```


# Welcome
Source: https://docs.tavily.com/welcome



<Visibility>
  # Build with Tavily

  Your journey to state-of-the-art web search starts right here.

  ## For AI agents

  Start with [https://docs.tavily.com/llms.txt](https://docs.tavily.com/llms.txt) for the full documentation index. Use [https://docs.tavily.com/agents.md](https://docs.tavily.com/agents.md) as the canonical Tavily setup guide — it routes you to the right connection model (SDK/API, MCP, or CLI + Skills) and capability. Use [https://docs.tavily.com/llms-full.txt](https://docs.tavily.com/llms-full.txt) when you need the full text of all docs.

  ## Installation

  **Python SDK**

  ```bash theme={null}
  pip install tavily-python
  ```

  **JavaScript SDK**

  ```bash theme={null}
  npm i @tavily/core
  ```

  ## Explore the APIs

  * [Search the web](/documentation/api-reference/endpoint/search)
  * [Extract webpages](/documentation/api-reference/endpoint/extract)
  * [Crawl webpages](/documentation/api-reference/endpoint/crawl)
  * [Map webpages](/documentation/api-reference/endpoint/map)
  * [Create a Research Task](/documentation/api-reference/endpoint/research)

  ## Developer resources

  * [API Credits Overview](/documentation/api-credits)
  * [Rate Limits](/documentation/rate-limits)
  * [Playground](https://app.tavily.com/playground)
</Visibility>

<Visibility>
  <div>
    <div>
      <h1>
        Build with <span>Tavily</span>
      </h1>

      <p>
        Your journey to state-of-the-art web search starts right here.
      </p>
    </div>

    <div>
      <div>
        <div>
          Installation
        </div>

        <Columns>
          <Card title="Python SDK" icon="python">
            ```bash theme={null}
            pip install tavily-python
            ```
          </Card>

          <Card title="JavaScript SDK" icon="node">
            ```js theme={null}
            npm i @tavily/core
            ```
          </Card>
        </Columns>

        <div>
          Try it now
        </div>

        <Tabs>
          <Tab title="Search the web" icon="search">
            <CodeGroup>
              ```python Python theme={null}
              from tavily import TavilyClient

              tavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")
              response = tavily_client.search("Who is Leo Messi?")

              print(response)
              ```

              ```javascript JavaScript theme={null}
              const { tavily } = require("@tavily/core");

              const tvly = tavily({ apiKey: "tvly-YOUR_API_KEY" });
              const response = await tvly.search("Who is Leo Messi?");

              console.log(response);
              ```

              ```bash cURL theme={null}
              curl --request POST \
                --url https://api.tavily.com/search \
                --header 'Authorization: Bearer <token>' \
                --header 'Content-Type: application/json' \
                --data '
              {
                "query": "who is Leo Messi?",
                "auto_parameters": false,
                "topic": "general",
                "search_depth": "basic",
                "chunks_per_source": 3,
                "max_results": 1,
                "time_range": null,
                "start_date": "2025-02-09",
                "end_date": "2025-12-29",
                "include_answer": false,
                "include_raw_content": false,
                "include_images": false,
                "include_image_descriptions": false,
                "include_favicon": false,
                "include_domains": [],
                "exclude_domains": [],
                "country": null,
                "include_usage": false
              }
              '
              ```
            </CodeGroup>

            <a href="/documentation/api-reference/endpoint/search">
              Learn more about the Search API →
            </a>
          </Tab>

          <Tab title="Extract webpages" icon="file-code">
            <CodeGroup>
              ```python Python theme={null}
              from tavily import TavilyClient

              tavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")
              response = tavily_client.extract("https://en.wikipedia.org/wiki/Artificial_intelligence")

              print(response)
              ```

              ```javascript JavaScript theme={null}
              const { tavily } = require("@tavily/core");

              const tvly = tavily({ apiKey: "tvly-YOUR_API_KEY" });
              const response = await tvly.extract("https://en.wikipedia.org/wiki/Artificial_intelligence");

              console.log(response);
              ```

              ```bash cURL theme={null}
              curl --request POST \
                --url https://api.tavily.com/extract \
                --header 'Authorization: Bearer <token>' \
                --header 'Content-Type: application/json' \
                --data '
              {
                "urls": "https://en.wikipedia.org/wiki/Artificial_intelligence",
                "query": "<string>",
                "chunks_per_source": 3,
                "extract_depth": "basic",
                "include_images": false,
                "include_favicon": false,
                "format": "markdown",
                "timeout": "None",
                "include_usage": false
              }
              '
              ```
            </CodeGroup>

            <a href="/documentation/api-reference/endpoint/extract">
              Learn more about the Extract API →
            </a>
          </Tab>

          <Tab title="Crawl webpages" icon="spider">
            <CodeGroup>
              ```python Python theme={null}
              from tavily import TavilyClient

              tavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")
              response = tavily_client.crawl("https://docs.tavily.com", instructions="Find all pages on the Python SDK")

              print(response)
              ```

              ```javascript JavaScript theme={null}
              const { tavily } = require("@tavily/core");

              const tvly = tavily({ apiKey: "tvly-YOUR_API_KEY" });
              const response = await tvly.crawl("https://docs.tavily.com", { instructions: "Find all pages on the Python SDK" });

              console.log(response);
              ```

              ```bash cURL theme={null}
              curl --request POST \
                --url https://api.tavily.com/crawl \
                --header 'Authorization: Bearer <token>' \
                --header 'Content-Type: application/json' \
                --data '
              {
                "url": "docs.tavily.com",
                "instructions": "Find all pages about the Python SDK",
                "chunks_per_source": 3,
                "max_depth": 1,
                "max_breadth": 20,
                "limit": 50,
                "select_paths": null,
                "select_domains": null,
                "exclude_paths": null,
                "exclude_domains": null,
                "allow_external": true,
                "include_images": false,
                "extract_depth": "basic",
                "format": "markdown",
                "include_favicon": false,
                "timeout": 150,
                "include_usage": false
              }
              '
              ```
            </CodeGroup>

            <a href="/documentation/api-reference/endpoint/crawl">
              Learn more about the Crawl API →
            </a>
          </Tab>

          <Tab title="Map webpages" icon="map">
            <CodeGroup>
              ```python Python theme={null}
              from tavily import TavilyClient

              tavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")
              response = tavily_client.map("https://docs.tavily.com")

              print(response)
              ```

              ```javascript JavaScript theme={null}
              const { tavily } = require("@tavily/core");

              const tvly = tavily({ apiKey: "tvly-YOUR_API_KEY" });
              const response = await tvly.map("https://docs.tavily.com");

              console.log(response);
              ```

              ```bash cURL theme={null}
              curl --request POST \
                --url https://api.tavily.com/map \
                --header 'Authorization: Bearer <token>' \
                --header 'Content-Type: application/json' \
                --data '
              {
                "url": "docs.tavily.com",
                "instructions": "Find all pages about the Python SDK",
                "max_depth": 1,
                "max_breadth": 20,
                "limit": 50,
                "select_paths": null,
                "select_domains": null,
                "exclude_paths": null,
                "exclude_domains": null,
                "allow_external": true,
                "timeout": 150,
                "include_usage": false
              }
              '
              ```
            </CodeGroup>

            <a href="/documentation/api-reference/endpoint/map">
              Learn more about the Map API →
            </a>
          </Tab>

          <Tab title="Create Research Task" icon="book">
            <CodeGroup>
              ```python Python theme={null}
              from tavily import TavilyClient

              tavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")
              response = tavily_client.research("What are the latest developments in AI?")

              print(response)
              ```

              ```javascript JavaScript theme={null}
              const { tavily } = require("@tavily/core");

              const tvly = tavily({ apiKey: "tvly-YOUR_API_KEY" });
              const response = await tvly.research("What are the latest developments in AI?");

              console.log(response);
              ```

              ```bash cURL theme={null}
              curl --request POST \
                --url https://api.tavily.com/research \
                --header 'Authorization: Bearer <token>' \
                --header 'Content-Type: application/json' \
                --data '
              {
                "input": "What are the latest developments in AI?",
                "model": "auto",
                "stream": false,
                "output_schema": {
                  "properties": {
                    "company": {
                      "type": "string",
                      "description": "The name of the company"
                    },
                    "key_metrics": {
                      "type": "array",
                      "description": "List of key performance metrics",
                      "items": {
                        "type": "string"
                      }
                    },
                    "financial_details": {
                      "type": "object",
                      "description": "Detailed financial breakdown",
                      "properties": {
                        "operating_income": {
                          "type": "number",
                          "description": "Operating income for the period"
                        }
                      }
                    }
                  },
                  "required": [
                    "company"
                  ]
                },
                "citation_format": "numbered"
              }
              '
              ```
            </CodeGroup>

            <a href="/documentation/api-reference/endpoint/research">
              Learn more about the Research API →
            </a>
          </Tab>
        </Tabs>
      </div>
    </div>

    <div>
      <div />

      <h3>
        Developer Resources
      </h3>
    </div>

    <div>
      <CardGroup>
        <Card title="API Credits Overview" icon="book-open" href="/documentation/api-credits">
          Learn how Tavily API credits work.
        </Card>

        <Card title="Rate Limits" icon="gauge" href="/documentation/rate-limits">
          Understand Tavily's rate limits and policies.
        </Card>

        <Card title="Playground" icon="play" href="https://app.tavily.com/playground">
          Try Tavily's APIs interactively.
        </Card>
      </CardGroup>
    </div>
  </div>

  <div>
    <div>
      <div>
        <Icon icon="circle-question" />

        <span>
          <span>Question?</span>

          <a href="mailto:support@tavily.com">
            Contact Us
          </a>
        </span>
      </div>

      <div>
        <Icon icon="discourse" />

        <span>
          <span>Integration issues?</span>

          <a href="https://community.tavily.com/">
            Join Community
          </a>
        </span>
      </div>

      <div>
        <Icon icon="sparkles" />

        <span>
          <span>Using LLMs?</span>

          <a href="/llms.txt">
            Read LLMs.txt
          </a>
        </span>
      </div>

      <div>
        <Icon icon="robot" />

        <span>
          <span>Building agents?</span>

          <a href="/agents">
            Read the Agents guide
          </a>
        </span>
      </div>

      <div>
        <Icon icon="circle-check" />

        <span>
          <span>Something not right?</span>

          <a href="https://status.tavily.com/">
            Check Status
          </a>
        </span>
      </div>
    </div>

    <div />

    <div>
      <div>
        <div>
          <div>
            <span>© Tavily</span>

            <a href="https://www.tavily.com/privacy">
              Privacy Policy
            </a>

            <span>·</span>

            <a href="https://www.tavily.com/website-terms">
              Website Terms of Use
            </a>

            <span>·</span>

            <a href="https://www.tavily.com/terms">
              Platform Terms of Use
            </a>

            <span>·</span>

            <a href="https://www.tavily.com/cookie-policy">
              Cookie Notice
            </a>

            <span>·</span>

            <a href="#" aria-label="Open cookie settings">
              Cookies Settings
            </a>

            <span>·</span>

            <a href="#" aria-label="Open accessibility menu">
              Accessibility Menu
            </a>
          </div>

          <div>
            <a href="https://www.linkedin.com/company/tavily" aria-label="LinkedIn">
              <Icon icon="linkedin" />
            </a>

            <a href="https://x.com/tavilyai" aria-label="Twitter">
              <Icon icon="twitter" />
            </a>

            <a href="https://github.com/tavily-ai" aria-label="GitHub">
              <Icon icon="github" />
            </a>

            <a href="https://www.youtube.com/@TavilyAI" aria-label="YouTube">
              <Icon icon="youtube" />
            </a>
          </div>
        </div>
      </div>
    </div>
  </div>
</Visibility>