> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tavily.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Tavily Agent Skills

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

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

  <Card title="Get API Key" icon="key" href="https://app.tavily.com" horizontal>
    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" defaultOpen="true">
    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>