---
title: "firecrawl/cli"
description: "CLI and Agent Skill for Firecrawl - Add scrape, search, and browsing capabilities to your AI agents"
source: https://github.com/firecrawl/cli
ref: main
license: null
licenseName: "No licence detected"
canonical: https://skillsdocs.com/firecrawl/cli
base: https://github.com/firecrawl/cli/blob/main/
provenance: authored
chapters: 13
inlined: 0
withheld: 13
words: 6940
updated: 2026-09-23T15:51:29Z
generator: "Skills Docs"
---

> **firecrawl/cli** — every Agent Skill in this repository, inlined verbatim.
>
> Canonical HTML: https://skillsdocs.com/firecrawl/cli
> Per-skill Markdown: https://skillsdocs.com/firecrawl/cli/<skill>.md
> Machine manifest: https://skillsdocs.com/firecrawl/cli/.well-known/agent-skills/index.json
> JSON: https://skillsdocs.com/api/v1/books/firecrawl/cli
> Install: `npx skills add firecrawl/cli`
> Upstream: https://github.com/firecrawl/cli @ `main`
> Licence: No licence detected — all rights reserved by its authors
>
> Content is mirrored from GitHub and © its authors, served unmodified. Takedown: https://github.com/DreambaseAI/skillsdocs/issues/new?labels=takedown&title=Takedown+request

# firecrawl/cli

CLI and Agent Skill for Firecrawl - Add scrape, search, and browsing capabilities to your AI agents

- **Skills:** 13
- **Inlined:** 0 (licence detected)
- **Words:** 6,940
- **Reading time:** 34 min
- **Stars:** 639

## Table of contents

1. [firecrawl-agent](https://skillsdocs.com/firecrawl/cli/firecrawl-agent.md) — Not licensed for republication — link only.
2. [firecrawl-alexandria](https://skillsdocs.com/firecrawl/cli/firecrawl-alexandria.md) — Not licensed for republication — link only.
3. [firecrawl-crawl](https://skillsdocs.com/firecrawl/cli/firecrawl-crawl.md) — Not licensed for republication — link only.
4. [firecrawl-developer-index](https://skillsdocs.com/firecrawl/cli/firecrawl-developer-index.md) — Not licensed for republication — link only.
5. [firecrawl-download](https://skillsdocs.com/firecrawl/cli/firecrawl-download.md) — Not licensed for republication — link only.
6. [firecrawl-interact](https://skillsdocs.com/firecrawl/cli/firecrawl-interact.md) — Not licensed for republication — link only.
7. [firecrawl-map](https://skillsdocs.com/firecrawl/cli/firecrawl-map.md) — Not licensed for republication — link only.
8. [firecrawl-monitor](https://skillsdocs.com/firecrawl/cli/firecrawl-monitor.md) — Not licensed for republication — link only.
9. [firecrawl-parse](https://skillsdocs.com/firecrawl/cli/firecrawl-parse.md) — Not licensed for republication — link only.
10. [firecrawl-research-index](https://skillsdocs.com/firecrawl/cli/firecrawl-research-index.md) — Not licensed for republication — link only.
11. [firecrawl-scrape](https://skillsdocs.com/firecrawl/cli/firecrawl-scrape.md) — Not licensed for republication — link only.
12. [firecrawl-search](https://skillsdocs.com/firecrawl/cli/firecrawl-search.md) — Not licensed for republication — link only.
13. [firecrawl](https://skillsdocs.com/firecrawl/cli/firecrawl.md) — Not licensed for republication — link only.

## Licence notice

13 of 13 skills in this book have no licence that we could detect, at either the repository or the skill level. Their bodies are **not** reproduced here and they are **not** listed in the Agent Skills manifest. Read them upstream:

- firecrawl-agent — https://github.com/firecrawl/cli/blob/main/skills/firecrawl-agent/SKILL.md
- firecrawl-alexandria — https://github.com/firecrawl/cli/blob/main/skills/firecrawl-alexandria/SKILL.md
- firecrawl-crawl — https://github.com/firecrawl/cli/blob/main/skills/firecrawl-crawl/SKILL.md
- firecrawl-developer-index — https://github.com/firecrawl/cli/blob/main/skills/firecrawl-developer-index/SKILL.md
- firecrawl-download — https://github.com/firecrawl/cli/blob/main/skills/firecrawl-download/SKILL.md
- firecrawl-interact — https://github.com/firecrawl/cli/blob/main/skills/firecrawl-interact/SKILL.md
- firecrawl-map — https://github.com/firecrawl/cli/blob/main/skills/firecrawl-map/SKILL.md
- firecrawl-monitor — https://github.com/firecrawl/cli/blob/main/skills/firecrawl-monitor/SKILL.md
- firecrawl-parse — https://github.com/firecrawl/cli/blob/main/skills/firecrawl-parse/SKILL.md
- firecrawl-research-index — https://github.com/firecrawl/cli/blob/main/skills/firecrawl-research-index/SKILL.md
- firecrawl-scrape — https://github.com/firecrawl/cli/blob/main/skills/firecrawl-scrape/SKILL.md
- firecrawl-search — https://github.com/firecrawl/cli/blob/main/skills/firecrawl-search/SKILL.md
- firecrawl — https://github.com/firecrawl/cli/blob/main/skills/firecrawl/SKILL.md

## Front matter

_The repository README, verbatim except that relative links are resolved against https://github.com/firecrawl/cli/blob/main/._

# 🔥 Firecrawl CLI

Command-line interface for Firecrawl. Search, scrape, interact, crawl, map, search research papers and developer sources, and run agent jobs directly from your terminal.

## Installation

```bash
npm install -g firecrawl-cli
```

Or set up everything in one command (install CLI globally, authenticate, and add skills across all detected coding editors):

```bash
npx -y firecrawl-cli@latest init -y --browser
```

- `-y` runs setup non-interactively
- `--browser` opens the browser for Firecrawl authentication automatically
- skills install globally to every detected AI coding agent by default

### Setup Skills, Workflows, and MCP

If you are using an AI coding agent like Claude Code, you can also install skill groups manually — one command per family:

```bash
firecrawl setup core       # scrape/search/crawl/interact primitives + index skills ("skills" is an alias)
firecrawl setup build      # app-integration skills for the Firecrawl API
firecrawl setup workflows  # end-to-end recipes (lead gen, deep research, ...)
```

Or install a single skill by name — the `firecrawl-` prefix is optional:

```bash
firecrawl setup developer-index
firecrawl setup seo-audit
```

If no API key is found afterwards, an interactive terminal offers a browser login (pass `--browser` to log in without the prompt); non-interactive runs never block — they print a hint and the skills walk agents through setup on first use.

These install globally across all detected coding editors by default. Use `--agent <agent>` to scope any of them to one editor.

#### Scope setup to a single harness

By default skills route to every detected harness. To install and route to only
one harness in a single command:

```bash
# One-shot from the install script (non-interactive, no TTY needed)
curl -fsSL https://firecrawl.dev/install.sh | bash -s -- --agent openclaw

# Or, once the CLI is installed
firecrawl init --agent openclaw          # only OpenClaw
firecrawl setup skills --agent openclaw
firecrawl setup workflows --agent openclaw
```

Any args after `bash -s --` are forwarded to `firecrawl init`, so you can add
things like `--skip-auth` for a skills-only, no-login setup. When you run
`firecrawl init` interactively without `--agent`, it shows a checkbox of your
detected harnesses (all selected by default) so you can pick a subset.

| Harness      | `--agent` value |
| ------------ | --------------- |
| Claude Code  | `claude-code`   |
| Codex        | `codex`         |
| Cursor       | `cursor`        |
| Windsurf     | `windsurf`      |
| OpenCode     | `opencode`      |
| OpenClaw     | `openclaw`      |
| OpenHands    | `openhands`     |
| Hermes Agent | `hermes-agent`  |

### Agent skills

The init command installs the **CLI skills** by default and offers the **workflow skills** as optional extras, into AI coding agents (Cursor, Claude Code, Windsurf, etc.):

- **CLI skills** — teach agents how to use the Firecrawl CLI for live web work (search, scrape, interact, map, crawl, agent). Installed by default.
- **Workflow skills** — teach agents how to produce Firecrawl-powered deliverables such as research briefs, SEO audits, QA reports, lead lists, knowledge bases, and design-system extraction. Interactive multi-select during init.

All skill families live in the [`firecrawl/skills`](https://github.com/firecrawl/skills) catalog — including the **build skills** for integrating Firecrawl into application code:

```bash
npx skills add firecrawl/skills
```

> Contributing skills? CLI skills (including the research/developer index skills) → PR this repo (`skills/`). Build/SDK skills → PR the [`firecrawl`](https://github.com/firecrawl/firecrawl) monorepo (`skills/`). Workflow skills → PR [`firecrawl/firecrawl-workflows`](https://github.com/firecrawl/firecrawl-workflows). The catalog ([`firecrawl/skills`](https://github.com/firecrawl/skills)) is read-only — never PR it directly.

To reinstall skills manually:

```bash
firecrawl setup core
firecrawl setup build
firecrawl setup workflows
```

To install the Firecrawl MCP server into your editors (Cursor, Claude Code, VS Code, etc.):

```bash
firecrawl setup mcp
```

To make Firecrawl the default web provider for supported AI agents:

```bash
firecrawl setup defaults    # or: firecrawl make default
```

This disables native web fetch/search where supported so agents route web work
through Firecrawl. When run interactively, it asks harness by harness (Claude
Code, Codex) so you can choose exactly which to change. Use `-y` to skip the
picker and apply to all, or `--agent` to target one:

```bash
firecrawl setup defaults --agent codex      # only Codex
firecrawl setup defaults -y                  # all harnesses, no prompts
```

To undo those config changes (also interactive, harness by harness):

```bash
firecrawl setup defaults --undo              # pick which to restore
firecrawl setup defaults --undo --agent claude
```

## Quick Start

Just run a command - the CLI will prompt you to authenticate if needed:

```bash
firecrawl https://example.com
```

## Authentication

On first run, you'll be prompted to authenticate:

```
  🔥 firecrawl cli
  Search, scrape, and interact with the web

Welcome! To get started, authenticate with your Firecrawl account.

  1. Login with browser (recommended)
  2. Enter API key manually

Tip: You can also set FIRECRAWL_API_KEY environment variable

Enter choice [1/2]:
```

### Authentication Methods

```bash
# Interactive (prompts automatically when needed)
firecrawl

# Browser login
firecrawl login

# Direct API key
firecrawl login --api-key fc-your-api-key

# Environment variable
export FIRECRAWL_API_KEY=fc-your-api-key

# Per-command API key
firecrawl scrape https://example.com --api-key fc-your-api-key
```

### Self-hosted / Local Development

For self-hosted Firecrawl instances or local development, use the `--api-url` option:

```bash
# Use a local Firecrawl instance (no API key required)
firecrawl --api-url http://localhost:3002 scrape https://example.com

# Or set via environment variable
export FIRECRAWL_API_URL=http://localhost:3002
firecrawl scrape https://example.com

# Self-hosted with API key
firecrawl --api-url https://firecrawl.mycompany.com --api-key fc-xxx scrape https://example.com
```

When using a custom API URL (anything other than `https://api.firecrawl.dev`), authentication is automatically skipped, allowing you to use local instances without an API key.

---

## Commands

### `scrape` - Scrape URLs

Extract content from any webpage. Pass multiple URLs to scrape them concurrently -- each result is saved to `.firecrawl/` automatically.

```bash
# Basic usage (outputs markdown)
firecrawl https://example.com
firecrawl scrape https://example.com

# Get raw HTML
firecrawl https://example.com --html
firecrawl https://example.com -H

# Multiple formats (outputs JSON)
firecrawl https://example.com --format markdown,links,images

# Save to file
firecrawl https://example.com -o output.md
firecrawl https://example.com --format json -o data.json --pretty

# Multiple URLs (scraped concurrently, each saved to .firecrawl/)
firecrawl scrape https://firecrawl.dev https://firecrawl.dev/blog https://docs.firecrawl.dev
```

#### Scrape Options

| Option                     | Description                                             |
| -------------------------- | ------------------------------------------------------- |
| `-f, --format <formats>`   | Output format(s), comma-separated                       |
| `-H, --html`               | Shortcut for `--format html`                            |
| `-S, --summary`            | Shortcut for `--format summary`                         |
| `--only-main-content`      | Extract only main content (removes navs, footers, etc.) |
| `--wait-for <ms>`          | Wait time before scraping (for JS-rendered content)     |
| `--screenshot`             | Take a screenshot                                       |
| `--full-page-screenshot`   | Take a full page screenshot                             |
| `--include-tags <tags>`    | Only include specific HTML tags                         |
| `--exclude-tags <tags>`    | Exclude specific HTML tags                              |
| `--max-age <milliseconds>` | Maximum age of cached content in milliseconds           |
| `--lockdown`               | Enable lockdown mode for the scrape                     |
| `--redact-pii`             | Redact personally identifiable information from output  |
| `--schema <json>`          | JSON schema for structured extraction                   |
| `--schema-file <path>`     | Path to JSON schema file for structured extraction      |
| `--actions <json>`         | JSON actions array to run during scrape                 |
| `--actions-file <path>`    | Path to JSON actions file                               |
| `--proxy <proxy>`          | Proxy mode for scraping (for example, `auto`, `basic`)  |
| `-o, --output <path>`      | Save output to file                                     |
| `--json`                   | Output as JSON format                                   |
| `--pretty`                 | Pretty print JSON output                                |
| `--timing`                 | Show request timing info                                |

#### Available Formats

| Format           | Description                  |
| ---------------- | ---------------------------- |
| `markdown`       | Clean markdown (default)     |
| `html`           | Cleaned HTML                 |
| `rawHtml`        | Original HTML                |
| `links`          | All links on the page        |
| `images`         | All images on the page       |
| `screenshot`     | Screenshot as base64         |
| `summary`        | AI-generated summary         |
| `json`           | Structured JSON extraction   |
| `changeTracking` | Track changes on the page    |
| `attributes`     | Page attributes and metadata |
| `branding`       | Brand identity extraction    |

#### Examples

```bash
# Extract only main content as markdown
firecrawl https://blog.example.com --only-main-content

# Wait for JS to render, then scrape
firecrawl https://spa-app.com --wait-for 3000

# Get all links from a page
firecrawl https://example.com --format links

# Screenshot + markdown
firecrawl https://example.com --format markdown --screenshot

# Extract specific elements only
firecrawl https://example.com --include-tags article,main

# Exclude navigation and ads
firecrawl https://example.com --exclude-tags nav,aside,.ad
```

---

### `search` - Search the web

Search the web with query-relevant highlights and optionally scrape content from search results.

```bash
# Basic search
firecrawl search "firecrawl"

# Limit results
firecrawl search "AI news" --limit 10

# Search news sources
firecrawl search "tech startups" --sources news

# Search images
firecrawl search "landscape photography" --sources images

# Multiple sources
firecrawl search "machine learning" --sources web,news,images

# Filter by category (research-affiliated websites, PDFs, developer index)
firecrawl search "transformer architecture" --categories research
firecrawl search "machine learning" --categories pdf,research

# Note: --categories research narrows *web* results to research-affiliated
# websites. To search papers themselves, use `firecrawl research search-papers`.

# Developer search: public repositories, GitHub issues, merged PRs, READMEs, and docs
firecrawl search "axum middleware ordering" --categories developer

# Time-based search
firecrawl search "AI announcements" --tbs qdr:d   # Past day
firecrawl search "tech news" --tbs qdr:w          # Past week

# Location-based search
firecrawl search "restaurants" --location "San Francisco,California,United States"
firecrawl search "local news" --country DE

# Search and scrape results
firecrawl search "firecrawl tutorials" --scrape
firecrawl search "API documentation" --scrape --scrape-formats markdown,links

# Output as pretty JSON
firecrawl search "AI data tools"
```

#### Search Options

| Option                       | Description                                                                                                                                                     |
| ---------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--limit <n>`                | Maximum results (default: 5, max: 100)                                                                                                                          |
| `--sources <sources>`        | Comma-separated: `web`, `images`, `news` (default: web)                                                                                                         |
| `--categories <categories>`  | Comma-separated: `research` (research-affiliated websites -- for papers use [`research search-papers`](#research---search-research-papers)), `pdf`, `developer` |
| `--tbs <value>`              | Time filter: `qdr:h` (hour), `qdr:d` (day), `qdr:w` (week), `qdr:m` (month), `qdr:y` (year)                                                                     |
| `--location <location>`      | Geo-targeting (e.g., "Germany", "San Francisco,California,United States")                                                                                       |
| `--country <code>`           | ISO country code (default: US)                                                                                                                                  |
| `--timeout <ms>`             | Timeout in milliseconds (default: 60000)                                                                                                                        |
| `--highlights`               | Query-relevant highlights for web and news when available (default)                                                                                             |
| `--no-highlights`            | Keep the original search snippets                                                                                                                               |
| `--ignore-invalid-urls`      | Exclude URLs invalid for other Firecrawl endpoints                                                                                                              |
| `--scrape`                   | Enable scraping of search results                                                                                                                               |
| `--scrape-formats <formats>` | Scrape formats when `--scrape` enabled (default: markdown)                                                                                                      |
| `--only-main-content`        | Include only main content when scraping (default: true)                                                                                                         |
| `-o, --output <path>`        | Save to file                                                                                                                                                    |
| `--json`                     | Output as compact JSON                                                                                                                                          |

#### Examples

```bash
# Research a topic with recent results
firecrawl search "React Server Components" --tbs qdr:m --limit 10

# Search public developer sources
firecrawl search "web data library" --categories developer --limit 20

# Search and get full content
firecrawl search "firecrawl documentation" --scrape --scrape-formats markdown --json -o results.json

# Find research papers -- use the paper index, not the website filter
firecrawl research search-papers "large language models" --json

# Narrow web results to research-affiliated websites (not the paper index)
firecrawl search "large language models" --categories research --json

# Answer a programming question from public repositories, GitHub issues, merged PRs, READMEs, and docs
firecrawl search "tokio select cancellation safety" --categories developer --json

# Search with location targeting
firecrawl search "best coffee shops" --location "Berlin,Germany" --country DE

# Get news from the past week
firecrawl search "AI startups funding" --sources news --tbs qdr:w --limit 15
```

---

### `developer` - Search developer sources

Search an index built for coding agents: public repositories, GitHub issues, merged pull requests, repository READMEs, and curated documentation sites. Use it for a programming question: code behaviour, a library or framework, an API contract, an error message, or a known bug.

The CLI intentionally keeps this agent-facing surface lean: it accepts only the query and result count. Express repository, source, result-kind, language, topic, license, and other scoping intent in the query text; semantic retrieval handles the scoping. For advanced filters, use the [Developer Index REST API](https://docs.firecrawl.dev/features/developer).

```bash
firecrawl developer "axum middleware ordering"
```

#### Options

| Option                | Description                                                |
| --------------------- | ---------------------------------------------------------- |
| `--limit <n>`         | Number of results (default: 10, max: 100)                  |
| `-o, --output <path>` | Save to file                                               |
| `--json`              | Output full response, including citations and index status |
| `--pretty`            | Pretty print JSON output                                   |

#### Examples

```bash
# Investigate a known bug
firecrawl developer "tokio spawn_blocking panics thread limit" --limit 10

# Put repository and evidence-kind intent directly in the semantic query
firecrawl developer "tokio select cancellation safety in tokio-rs/tokio issues and merged pull requests"

# Keep the full response, including passages, citations, and licenses
firecrawl developer "tokio select cancellation safety" --json -o results.json
```

---

### `research` - Search research papers

Search Firecrawl's research paper index: roughly 43M abstracts, around 90% biomedical (PubMed, bioRxiv, medRxiv) plus arXiv. Use this for biomedical, clinical, and scientific literature rather than scraping PubMed, bioRxiv, or Google Scholar by hand.

This is **not** the same thing as `firecrawl search --categories research`, which only narrows ordinary web results to research-affiliated websites.

```bash
# Find papers by topic (start here)
firecrawl research search-papers "CRISPR base editing off-target effects" --limit 20

# Full metadata for one paper, by any supported id form
firecrawl research inspect-paper pmid:40953549

# Expand along the citation graph from your strongest hits
firecrawl research related-papers pmcid:PMC12530322 --intent "in vivo delivery"

# Read full-text passages to verify a specific claim
firecrawl research read-paper doi:10.1016/j.neunet.2025.108095 --question "What was the sample size?"

# Search GitHub issue/PR history and repository READMEs
firecrawl research search-github "foundationdb queue worker shutdown" --limit 10
```

Paper ids accept `pmid:`, `pmcid:`, `doi:`, and `arxiv:` forms, plus canonical `paperId` values returned by search.

#### Subcommands

| Subcommand                    | Description                                                                 |
| ----------------------------- | --------------------------------------------------------------------------- |
| `search-papers <query>`       | Semantic (HyDE) search over paper abstracts. The primary entry point.       |
| `inspect-paper <paperId>`     | Canonical metadata: title, abstract, authors, categories, source ids, dates |
| `related-papers <seedIds...>` | Citation-graph expansion from seed papers, ranked against `--intent`        |
| `read-paper <paperId>`        | Best-matching in-body full-text passages for a `--question`                 |
| `search-github <query>`       | GitHub issue/PR history and repository READMEs                              |

#### `search-papers` Options

| Option                      | Description                                                                            |
| --------------------------- | -------------------------------------------------------------------------------------- |
| `--limit <n>`               | Number of results (default: 40)                                                        |
| `--authors <authors>`       | Comma-separated author substring filter(s); all must match                             |
| `--categories <categories>` | arXiv-style taxonomy labels (e.g. `cs.LG,cs.IR`). Biomedical records do not use these. |
| `--from <date>`             | Inclusive lower bound on created/updated date (YYYY-MM-DD)                             |
| `--to <date>`               | Inclusive upper bound on created/updated date (YYYY-MM-DD)                             |
| `-o, --output <path>`       | Save to file                                                                           |
| `--json`                    | Output as compact JSON                                                                 |
| `--pretty`                  | Pretty print JSON output                                                               |

#### Tips

- Run several distinct framings of the same question rather than one query -- recall improves markedly.
- Use `search-papers` to find anchors, `related-papers` to expand, then `read-paper` to verify a candidate before including it.

---

### `feedback` - Send endpoint job feedback

Send concise feedback for a completed v2 `search`, `scrape`, `parse`, or `map`
job. For search-result quality, `search-feedback` is still the most guided
command; `feedback` is the generic endpoint/job surface.

```bash
firecrawl feedback scrape 0193f6c5-1234-7890-abcd-1234567890ab \
  --rating partial \
  --issues missing_markdown \
  --tags docs \
  --note "The pricing table was missing from the markdown output." \
  --url https://example.com/pricing \
  --page-numbers 1
```

Keep notes and metadata small. Do not send raw scrape or parse outputs as
feedback.

Set `FIRECRAWL_NO_ENDPOINT_FEEDBACK=1` to make `firecrawl feedback` skip
endpoint feedback calls silently.

#### Feedback Options

| Option                           | Description                                  |
| -------------------------------- | -------------------------------------------- |
| `--rating <rating>`              | Required: `good`, `partial`, or `bad`        |
| `--issues <codesOrJson>`         | Comma-separated issue codes or JSON array    |
| `--tags <codesOrJson>`           | Comma-separated tags or JSON array           |
| `--note <text>`                  | Short human-readable feedback                |
| `--valuable-sources <json>`      | JSON array of `{url, reason}` entries        |
| `--missing-content <json>`       | JSON array of `{topic, description}` entries |
| `--query-suggestions <text>`     | Search/query improvement notes               |
| `--url <url>`                    | Relevant URL for scrape or parse feedback    |
| `--page-numbers <numbersOrJson>` | Comma-separated page numbers or JSON array   |
| `--metadata <json>`              | Small JSON object with extra context         |
| `--metadata-file <path>`         | Path to small metadata JSON object           |
| `--silent`                       | Suppress output for background agent calls   |

---

### `map` - Discover all URLs on a website

Quickly discover all URLs on a website without scraping content.

```bash
# List all URLs (one per line)
firecrawl map https://example.com

# Output as JSON
firecrawl map https://example.com --json

# Search for specific URLs
firecrawl map https://example.com --search "blog"

# Limit results
firecrawl map https://example.com --limit 500
```

#### Map Options

| Option                      | Description                       |
| --------------------------- | --------------------------------- |
| `--limit <n>`               | Maximum URLs to discover          |
| `--search <query>`          | Filter URLs by search query       |
| `--sitemap <mode>`          | `include`, `skip`, or `only`      |
| `--include-subdomains`      | Include subdomains                |
| `--ignore-query-parameters` | Dedupe URLs with different params |
| `--timeout <seconds>`       | Request timeout                   |
| `--json`                    | Output as JSON                    |
| `-o, --output <path>`       | Save to file                      |

#### Examples

```bash
# Find all product pages
firecrawl map https://shop.example.com --search "product"

# Get sitemap URLs only
firecrawl map https://example.com --sitemap only

# Save URL list to file
firecrawl map https://example.com -o urls.txt

# Include subdomains
firecrawl map https://example.com --include-subdomains --limit 1000
```

---

### `crawl` - Crawl an entire website

Crawl multiple pages from a website.

```bash
# Start a crawl (returns job ID)
firecrawl crawl https://example.com

# Wait for crawl to complete
firecrawl crawl https://example.com --wait

# With progress indicator
firecrawl crawl https://example.com --wait --progress

# Check crawl status
firecrawl crawl <job-id>

# Limit pages
firecrawl crawl https://example.com --limit 100 --max-depth 3
```

#### Crawl Options

| Option                         | Description                              |
| ------------------------------ | ---------------------------------------- |
| `--wait`                       | Wait for crawl to complete               |
| `--progress`                   | Show progress while waiting              |
| `--limit <n>`                  | Maximum pages to crawl                   |
| `--max-depth <n>`              | Maximum crawl depth                      |
| `--include-paths <paths>`      | Only crawl matching paths                |
| `--exclude-paths <paths>`      | Skip matching paths                      |
| `--sitemap <mode>`             | `include`, `skip`, or `only`             |
| `--allow-subdomains`           | Include subdomains                       |
| `--allow-external-links`       | Follow external links                    |
| `--crawl-entire-domain`        | Crawl entire domain                      |
| `--ignore-query-parameters`    | Treat URLs with different params as same |
| `--delay <ms>`                 | Delay between requests                   |
| `--max-concurrency <n>`        | Max concurrent requests                  |
| `--scrape-options <json>`      | JSON scrape options passed to each page  |
| `--scrape-options-file <path>` | Path to scrape options JSON file         |
| `--webhook <url-or-json>`      | Webhook URL or configuration             |
| `--cancel`                     | Cancel an active crawl job by job ID     |
| `--timeout <seconds>`          | Timeout when waiting                     |
| `--poll-interval <seconds>`    | Status check interval                    |

#### Examples

```bash
# Crawl blog section only
firecrawl crawl https://example.com --include-paths /blog,/posts

# Exclude admin pages
firecrawl crawl https://example.com --exclude-paths /admin,/login

# Crawl with rate limiting
firecrawl crawl https://example.com --delay 1000 --max-concurrency 2

# Deep crawl with high limit
firecrawl crawl https://example.com --limit 1000 --max-depth 10 --wait --progress

# Save results
firecrawl crawl https://example.com --wait -o crawl-results.json --pretty
```

---

### `credit-usage` - Check your credits

```bash
# Show credit usage
firecrawl credit-usage

# Output as JSON
firecrawl credit-usage --json --pretty
```

---

### `agent` - AI-powered web data extraction

Run an AI agent that autonomously browses and extracts structured data from the web based on natural language prompts.

> **Note:** Agent tasks typically take **2 to 5 minutes** to complete, and sometimes longer for complex extractions. Use sparingly and consider `--max-credits` to limit costs.

```bash
# Basic usage (returns job ID immediately)
firecrawl agent "Find the pricing plans for Firecrawl"

# Wait for completion
firecrawl agent "Extract all product names and prices from this store" --wait

# Focus on specific URLs
firecrawl agent "Get the main features listed" --urls https://example.com/features

# Use structured output with JSON schema
firecrawl agent "Extract company info" --schema '{"type":"object","properties":{"name":{"type":"string"},"employees":{"type":"number"}}}'

# Load schema from file
firecrawl agent "Extract product data" --schema-file ./product-schema.json --wait

# Check status of an existing job
firecrawl agent <job-id>
firecrawl agent <job-id> --wait
```

#### Agent Options

| Option                      | Description                                                   |
| --------------------------- | ------------------------------------------------------------- |
| `--urls <urls>`             | Comma-separated URLs to focus extraction on                   |
| `--model <model>`           | `spark-1-mini` (default, cheaper) or `spark-1-pro` (accurate) |
| `--schema <json>`           | JSON schema for structured output (inline JSON string)        |
| `--schema-file <path>`      | Path to JSON schema file for structured output                |
| `--max-credits <number>`    | Maximum credits to spend (job fails if exceeded)              |
| `--webhook <url-or-json>`   | Webhook URL or configuration                                  |
| `--status`                  | Check status of existing agent job                            |
| `--cancel`                  | Cancel an active agent job by job ID                          |
| `--wait`                    | Wait for agent to complete before returning results           |
| `--poll-interval <seconds>` | Polling interval in seconds when waiting (default: 5)         |
| `--timeout <seconds>`       | Timeout in seconds when waiting (default: no timeout)         |
| `-o, --output <path>`       | Save output to file                                           |
| `--json`                    | Output as JSON format                                         |
| `--pretty`                  | Pretty print JSON output                                      |

#### Examples

```bash
# Research task with timeout
firecrawl agent "Find the top 5 competitors of Notion and their pricing" --wait --timeout 300

# Extract data with cost limit
firecrawl agent "Get all blog post titles and dates" --urls https://blog.example.com --max-credits 100 --wait

# Use higher accuracy model for complex extraction
firecrawl agent "Extract detailed technical specifications" --model spark-1-pro --wait --json --pretty

# Save structured results to file
firecrawl agent "Extract contact information" --schema-file ./contact-schema.json --wait --json -o contacts.json --pretty

# Check job status without waiting
firecrawl agent abc123-def456-... --json

# Poll a running job until completion
firecrawl agent abc123-def456-... --wait --poll-interval 10
```

---

### `interact` - Interact with scraped pages

Scrape a page, then interact with it in a live browser session using natural language or code. No manual session management required.

```bash
# 1. Scrape a page first
firecrawl scrape https://example.com

# 2. Interact with it
firecrawl interact "Click the pricing tab"
firecrawl interact "Fill in the email field with test@example.com"
firecrawl interact "Extract the pricing table"

# 3. Code execution (Playwright)
firecrawl interact -c "await page.title()"
firecrawl interact -c "print(await page.title())" --python

# 4. Stop the session
firecrawl interact stop
```

#### Interact Options

| Option                 | Description                                    |
| ---------------------- | ---------------------------------------------- |
| `-p, --prompt <text>`  | AI prompt (alternative to positional argument) |
| `-c, --code <code>`    | Code to execute in the browser sandbox         |
| `-s, --scrape-id <id>` | Scrape job ID (default: last scrape)           |
| `--python`             | Execute code as Python/Playwright              |
| `--node`               | Execute code as Node.js/Playwright (default)   |
| `--bash`               | Execute code as Bash                           |
| `--timeout <seconds>`  | Timeout in seconds (1-300, default: 30)        |
| `-o, --output <path>`  | Save output to file                            |
| `--json`               | Output as JSON format                          |

#### Profiles

Use `--profile` on the scrape to persist browser state across scrapes:

```bash
# Login and save state
firecrawl scrape "https://app.example.com/login" --profile my-app
firecrawl interact "Fill in email and click login"

# Come back authenticated later
firecrawl scrape "https://app.example.com/dashboard" --profile my-app
firecrawl interact "Extract the dashboard data"
```

---

### `monitor` - Watch pages for changes

Create monitors when the goal is ongoing change detection, alerting, or repeated checks over time. A monitor runs recurring scrapes or crawls, diffs each result against the last retained snapshot, and can notify webhooks or email recipients.

```bash
firecrawl monitor create --name "Blog" \
  --goal "Notify me when a new post is published" \
  --schedule "every 30 minutes" \
  --page https://example.com/blog \
  --email alerts@example.com

firecrawl monitor create --name "Product pages" \
  --goal "Notify me when pricing, docs, or changelog content changes" \
  --schedule "every 30 minutes" \
  --scrape-urls https://example.com/pricing,https://example.com/docs,https://example.com/changelog

firecrawl monitor create --name "Docs webhook" \
  --goal "Notify me when docs content changes" \
  --schedule "every 30 minutes" \
  --page https://example.com/docs \
  --webhook-url https://example.com/webhook \
  --webhook-events monitor.page,monitor.check.completed

firecrawl monitor list --limit 20
firecrawl monitor run <monitorId>
firecrawl monitor checks <monitorId>
firecrawl monitor check <monitorId> <checkId> --page-status changed
firecrawl monitor update <monitorId> --state paused
firecrawl monitor delete <monitorId>
```

#### Monitor Options

| Option                    | Description                                         |
| ------------------------- | --------------------------------------------------- |
| `--name <name>`           | Monitor name                                        |
| `--goal <goal>`           | What changes this monitor should look for           |
| `--cron <expression>`     | Cron schedule (e.g. `*/30 * * * *`)                 |
| `--schedule <text>`       | Natural-language schedule (e.g. `every 30 minutes`) |
| `--timezone <tz>`         | Schedule timezone (default: `UTC`)                  |
| `--page <url>`            | Single page URL to scrape on each check             |
| `--scrape-urls <list>`    | Comma-separated page URLs to scrape on each check   |
| `--crawl-url <url>`       | Root URL for a crawl target                         |
| `--webhook-url <url>`     | Webhook destination                                 |
| `--webhook-events <list>` | Comma-separated webhook events                      |
| `--email <list>`          | Comma-separated email recipients                    |
| `--retention-days <n>`    | Snapshot retention window                           |

For advanced targets such as JSON-mode `changeTracking`, pass a JSON payload:

```bash
firecrawl monitor create monitor.json
cat monitor.json | firecrawl monitor create
```

---

### `config` - Configure settings

```bash
# Configure with custom API URL
firecrawl config --api-url https://firecrawl.mycompany.com
firecrawl config --api-url http://localhost:3002 --api-key fc-xxx
```

### `view-config` - View current configuration

```bash
# View current configuration and authentication status
firecrawl view-config
```

Shows authentication status and stored credentials location.

---

### `login` / `logout`

```bash
# Login
firecrawl login
firecrawl login --method browser
firecrawl login --method manual
firecrawl login --api-key fc-xxx

# Login to self-hosted instance
firecrawl login --api-url https://firecrawl.mycompany.com
firecrawl login --api-url http://localhost:3002 --api-key fc-xxx

# Logout
firecrawl logout
```

---

## Global Options

These options work with any command:

| Option                | Description                                            |
| --------------------- | ------------------------------------------------------ |
| `--status`            | Show version, auth, concurrency, and credits           |
| `-k, --api-key <key>` | Use specific API key                                   |
| `--api-url <url>`     | Use custom API URL (for self-hosted/local development) |
| `-V, --version`       | Show version                                           |
| `-h, --help`          | Show help                                              |

### Check Status

```bash
firecrawl --status
```

```
  🔥 firecrawl cli v1.20.0

  ● Authenticated via stored credentials
  Concurrency: 0/100 jobs (parallel scrape limit)
  Credits: 500,000 / 1,000,000 (50% left this cycle)
```

---

## Output Handling

### Stdout vs File

```bash
# Output to stdout (default)
firecrawl https://example.com

# Pipe to another command
firecrawl https://example.com | head -50

# Save to file
firecrawl https://example.com -o output.md

# JSON output
firecrawl https://example.com --format links --pretty
```

### Format Behavior

- **Single format**: Outputs raw content (markdown text, HTML, etc.)
- **Multiple formats**: Outputs JSON with all requested data

```bash
# Raw markdown output
firecrawl https://example.com --format markdown

# JSON output with multiple formats
firecrawl https://example.com --format markdown,links,images
```

---

## Tips & Tricks

### Scrape multiple URLs

```bash
# Just pass multiple URLs -- results are saved to .firecrawl/
firecrawl scrape https://firecrawl.dev https://firecrawl.dev/blog https://docs.firecrawl.dev
```

### Combine with other tools

```bash
# Extract links and process with jq
firecrawl https://example.com --format links | jq '.links[].url'

# Convert to PDF (with pandoc)
firecrawl https://example.com | pandoc -o document.pdf

# Search within scraped content
firecrawl https://example.com | grep -i "keyword"
```

### CI/CD Usage

```bash
# Set API key via environment
export FIRECRAWL_API_KEY=${{ secrets.FIRECRAWL_API_KEY }}
firecrawl crawl https://docs.example.com --wait -o docs.json

# Use self-hosted instance
export FIRECRAWL_API_URL=${{ secrets.FIRECRAWL_API_URL }}
firecrawl scrape https://example.com -o output.md
```

---

## Telemetry

The CLI collects anonymous usage data during authentication to help improve the product:

- CLI version, OS, and Node.js version
- Detect development tools (e.g., Cursor, VS Code, Claude Code)

**No command data, URLs, or file contents are collected via the CLI.**

To disable telemetry, set the environment variable:

```bash
export FIRECRAWL_NO_TELEMETRY=1
```

---

## Experimental

Experimental commands live under `firecrawl experimental` (alias: `firecrawl x`).

### `download` - Bulk Site Download

Combines `map` + `scrape` to save a site as local files under `.firecrawl/`.

```bash
firecrawl x download https://docs.firecrawl.dev
firecrawl x download https://docs.firecrawl.dev --screenshot --limit 20 -y
firecrawl x download https://docs.firecrawl.dev --include-paths "/features,/sdks" -y
```

### Workflow Skills

The old experimental AI workflow commands have moved to the
[`firecrawl/skills`](https://github.com/firecrawl/skills) catalog
(`skills/workflows/`). Workflow skills infer from the user's request first and only ask
short clarifying questions when required inputs are missing. Install them with:

```bash
firecrawl setup workflows
```

---

## Documentation

For more details, visit the [Firecrawl Documentation](https://docs.firecrawl.dev).

### Alexandria tool shorthand

Use a provider/capability in place of a URL. The explicit `--alexandria` form remains supported:

```bash
firecrawl scrape benzinga/news/search --options '{"pageSize":10}'
firecrawl scrape firecrawl-research-index/read --options '{"paperId":"123","query":"methodology","k":4}'
firecrawl scrape --alexandria benzinga/news/search --options '{"pageSize":10}'
firecrawl scrape https://example.com
```

URLs (including domains, IP addresses and localhost) continue to scrape websites. Tool addresses go directly to Alexandria, which validates the provider and capability; they never fall back to URL scraping. There is no extra catalog lookup. Bare names such as `firecrawl scrape amazon` fail locally with a suggested website URL and directions to `firecrawl list`. Suggestions are not verified or executed. Mixing URLs and tools in one command is rejected.

### Alexandria provider terms

When a provider returns `THIRD_PARTY_DATA_TERMS_REQUIRED`, review its linked terms.
Read the current provider agreement and metadata with:

```bash
npx firecrawl-cli@latest alexandria terms show benzinga --pretty
```

After reviewing it, explicitly accept the exact version and digest for the organization
associated with your Firecrawl API key:

```bash
npx firecrawl-cli@latest alexandria terms accept benzinga \
  --terms-version '<reviewed-version>' --digest '<reviewed-sha256>' --confirm
```

This records acceptance of the reviewed Alexandria provider terms. No automatic
acceptance or retry occurs. A `409 terms_changed` requires reviewing the new agreement before retrying.
Agents must present the returned terms and provider links, ask the user for explicit
approval, and wait before accepting. If review is refused or a provider link is
unavailable, show the error and direct an organization admin to
https://www.firecrawl.dev/app/settings?tab=data-sources. Never infer consent from a
failed lookup or automatically retry an acceptance. The API remains authoritative
for organization access and acceptance authority.
After confirmed success, rerun the original provider command; its normal credits apply.

### Alexandria receipts and retries

Alexandria execution JSON includes an additive `receipt`: `creditsUsed` is actual reported usage (missing means unknown), `requestId` is the client idempotency identity, and `operationId`/`operationType` identify the server scrape. Existing response fields remain available. IDs, reported credits, and available retry delays print to stderr.

Use the same request ID to recover pending or uncertain execution. Completed results, including failures, replay under the same ID; a deliberate new execution needs a new ID and may charge again. Never automatically rotate an uncertain ID. Structured failures preserve available status, code, action and retry metadata.

### Alexandria session feedback

Report the outcome of a session, missing provider coverage, or capability issues:

```bash
firecrawl alexandria feedback --rating partial \
  --url https://example.com \
  --requested-functionality "Find records and download their attachments" \
  --rationale "Found summaries but could not retrieve attachments" --json
```

No job ID is required. Alexandria session feedback has no job-age deadline and does not refund credits. Optional `--provider-feedback` and `--capability-feedback` accept JSON arrays; see `firecrawl alexandria feedback --help` for their fields and issue codes. Capability issue codes are `new_capability_request` (requires `requestedFunctionality`), `missing_capability` (the provider exists but lacks this capability), `insufficient_functionality`, `incorrect_result`, `execution_error`, and `other`. Existing `feedback` and `search-feedback` commands retain their job-specific behavior. Endpoint feedback opt-out environment variables also apply to this command.

---

<!-- chapter:begin slug=firecrawl-agent position=1 -->

## 1. firecrawl-agent

Autonomously navigate websites and extract structured data across pages. Use when the task requires navigation or no suitable ready-made workflow or data provider covers it.

- **Source:** https://github.com/firecrawl/cli/blob/main/skills/firecrawl-agent/SKILL.md
- **Raw:** https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl-agent/SKILL.md
- **Markdown:** https://skillsdocs.com/firecrawl/cli/firecrawl-agent.md
- **Licence:** No licence detected — all rights reserved by its authors

_Body withheld: no licence could be detected for this skill. Read it upstream._

<!-- chapter:end slug=firecrawl-agent -->

---

<!-- chapter:begin slug=firecrawl-alexandria position=2 -->

## 2. firecrawl-alexandria

Find a direct path to structured data through ready-made workflows, data APIs, and indexes. Follow the search skill to discover and inspect tools, then the scrape skill to execute them.

- **Source:** https://github.com/firecrawl/cli/blob/main/skills/firecrawl-alexandria/SKILL.md
- **Raw:** https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl-alexandria/SKILL.md
- **Markdown:** https://skillsdocs.com/firecrawl/cli/firecrawl-alexandria.md
- **Licence:** No licence detected — all rights reserved by its authors

_Body withheld: no licence could be detected for this skill. Read it upstream._

<!-- chapter:end slug=firecrawl-alexandria -->

---

<!-- chapter:begin slug=firecrawl-crawl position=3 -->

## 3. firecrawl-crawl

Bulk-extract many pages from one site or section. Use for "crawl", "everything under /docs", or content spanning linked pages.

- **Source:** https://github.com/firecrawl/cli/blob/main/skills/firecrawl-crawl/SKILL.md
- **Raw:** https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl-crawl/SKILL.md
- **Markdown:** https://skillsdocs.com/firecrawl/cli/firecrawl-crawl.md
- **Licence:** No licence detected — all rights reserved by its authors

_Body withheld: no licence could be detected for this skill. Read it upstream._

<!-- chapter:end slug=firecrawl-crawl -->

---

<!-- chapter:begin slug=firecrawl-developer-index position=4 -->

## 4. firecrawl-developer-index

Search an index of public repositories, GitHub issues, merged pull requests, repository READMEs, and curated documentation sites. Use when a programming question needs external documentation or upstream evidence.

- **Source:** https://github.com/firecrawl/cli/blob/main/skills/firecrawl-developer-index/SKILL.md
- **Raw:** https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl-developer-index/SKILL.md
- **Markdown:** https://skillsdocs.com/firecrawl/cli/firecrawl-developer-index.md
- **Licence:** No licence detected — all rights reserved by its authors

_Body withheld: no licence could be detected for this skill. Read it upstream._

<!-- chapter:end slug=firecrawl-developer-index -->

---

<!-- chapter:begin slug=firecrawl-download position=5 -->

## 5. firecrawl-download

Save a site or section as local files (markdown, screenshots). Use for "download the site", offline docs, or a local copy for reference.

- **Source:** https://github.com/firecrawl/cli/blob/main/skills/firecrawl-download/SKILL.md
- **Raw:** https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl-download/SKILL.md
- **Markdown:** https://skillsdocs.com/firecrawl/cli/firecrawl-download.md
- **Licence:** No licence detected — all rights reserved by its authors

_Body withheld: no licence could be detected for this skill. Read it upstream._

<!-- chapter:end slug=firecrawl-download -->

---

<!-- chapter:begin slug=firecrawl-interact position=6 -->

## 6. firecrawl-interact

Drive a live browser on a scraped page: click, fill forms, log in, paginate, infinite-scroll. Use when content requires interaction or a scrape failed or returned incomplete content.

- **Source:** https://github.com/firecrawl/cli/blob/main/skills/firecrawl-interact/SKILL.md
- **Raw:** https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl-interact/SKILL.md
- **Markdown:** https://skillsdocs.com/firecrawl/cli/firecrawl-interact.md
- **Licence:** No licence detected — all rights reserved by its authors

_Body withheld: no licence could be detected for this skill. Read it upstream._

<!-- chapter:end slug=firecrawl-interact -->

---

<!-- chapter:begin slug=firecrawl-map position=7 -->

## 7. firecrawl-map

Discover and list a site's URLs, with search filtering. Use for "map the site" or "find the URL for" requests — when the user knows the site but not the exact page, or wants site structure.

- **Source:** https://github.com/firecrawl/cli/blob/main/skills/firecrawl-map/SKILL.md
- **Raw:** https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl-map/SKILL.md
- **Markdown:** https://skillsdocs.com/firecrawl/cli/firecrawl-map.md
- **Licence:** No licence detected — all rights reserved by its authors

_Body withheld: no licence could be detected for this skill. Read it upstream._

<!-- chapter:end slug=firecrawl-map -->

---

<!-- chapter:begin slug=firecrawl-monitor position=8 -->

## 8. firecrawl-monitor

Alert by webhook/email on web changes — use for "monitor/watch/track/alert me when": recurring checks on known URLs (prefer over repeated one-off scrapes) or web-wide watches for new results (queries + goal).

- **Source:** https://github.com/firecrawl/cli/blob/main/skills/firecrawl-monitor/SKILL.md
- **Raw:** https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl-monitor/SKILL.md
- **Markdown:** https://skillsdocs.com/firecrawl/cli/firecrawl-monitor.md
- **Licence:** No licence detected — all rights reserved by its authors

Bundled files (2), referenced from this skill's directory:
  - `goals.md` — https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl-monitor/goals.md
  - `json-tracking.md` — https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl-monitor/json-tracking.md

_Body withheld: no licence could be detected for this skill. Read it upstream._

<!-- chapter:end slug=firecrawl-monitor -->

---

<!-- chapter:begin slug=firecrawl-parse position=9 -->

## 9. firecrawl-parse

Convert a local file (PDF, DOCX, XLSX, HTML, …) to markdown, or answer questions about its content. Use whenever the input is a file path, not a URL.

- **Source:** https://github.com/firecrawl/cli/blob/main/skills/firecrawl-parse/SKILL.md
- **Raw:** https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl-parse/SKILL.md
- **Markdown:** https://skillsdocs.com/firecrawl/cli/firecrawl-parse.md
- **Licence:** No licence detected — all rights reserved by its authors

_Body withheld: no licence could be detected for this skill. Read it upstream._

<!-- chapter:end slug=firecrawl-parse -->

---

<!-- chapter:begin slug=firecrawl-research-index position=10 -->

## 10. firecrawl-research-index

Find the papers that answer a research query in Firecrawl's research paper index — a corpus of paper abstracts whose largest share is biomedical and life-science literature (PubMed, bioRxiv, medRxiv), alongside arXiv preprints in CS, physics, and math — using semantic search, semantic and structural expansion, and in-body verification. Use this skill for literature-finding and paper-retrieval tasks of any kind, including clinical, biomedical, drug, gene, disease, and other life-science questions, whether the answer is a single paper or a full multi-paper set. The index is reached only through the `firecrawl_research_*` MCP tools or the `firecrawl research` CLI subcommands. Calling `firecrawl_search` with its `categories` option set to `["research"]` is a different feature — it filters ordinary web search to research-affiliated websites (the list includes PubMed, bioRxiv, medRxiv, arXiv, and publisher sites) and returns page results from them, without querying the paper records in this index.

- **Source:** https://github.com/firecrawl/cli/blob/main/skills/firecrawl-research-index/SKILL.md
- **Raw:** https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl-research-index/SKILL.md
- **Markdown:** https://skillsdocs.com/firecrawl/cli/firecrawl-research-index.md
- **Licence:** No licence detected — all rights reserved by its authors

_Body withheld: no licence could be detected for this skill. Read it upstream._

<!-- chapter:end slug=firecrawl-research-index -->

---

<!-- chapter:begin slug=firecrawl-scrape position=11 -->

## 11. firecrawl-scrape

Read a known webpage or execute a discovered workflow or data-provider capability. Use for page content or structured results once the URL or tool is selected.

- **Source:** https://github.com/firecrawl/cli/blob/main/skills/firecrawl-scrape/SKILL.md
- **Raw:** https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl-scrape/SKILL.md
- **Markdown:** https://skillsdocs.com/firecrawl/cli/firecrawl-scrape.md
- **Licence:** No licence detected — all rights reserved by its authors

Bundled files (1), referenced from this skill's directory:
  - `references/large-results.md` — https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl-scrape/references/large-results.md

_Body withheld: no licence could be detected for this skill. Read it upstream._

<!-- chapter:end slug=firecrawl-scrape -->

---

<!-- chapter:begin slug=firecrawl-search position=12 -->

## 12. firecrawl-search

Find web sources with query-relevant page excerpts and optional full-page content, and discover workflows, data APIs, and indexes. Use for web research or finding structured records, listings, transcripts, and datasets. Supports semantic tool discovery, domain matching, and progressive catalogue browsing.

- **Source:** https://github.com/firecrawl/cli/blob/main/skills/firecrawl-search/SKILL.md
- **Raw:** https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl-search/SKILL.md
- **Markdown:** https://skillsdocs.com/firecrawl/cli/firecrawl-search.md
- **Licence:** No licence detected — all rights reserved by its authors

_Body withheld: no licence could be detected for this skill. Read it upstream._

<!-- chapter:end slug=firecrawl-search -->

---

<!-- chapter:begin slug=firecrawl position=13 -->

## 13. firecrawl

Any live-web task via the Firecrawl CLI — including ordinary web research: searching the web, reading or extracting pages, gathering sources, discovering site URLs, bulk extraction, downloading a site, change alerts, or pages needing clicks/login — web only; local files route to firecrawl-parse. For papers use firecrawl-research-index; for library, API, error, or bug questions use firecrawl-developer-index.

- **Source:** https://github.com/firecrawl/cli/blob/main/skills/firecrawl/SKILL.md
- **Raw:** https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl/SKILL.md
- **Markdown:** https://skillsdocs.com/firecrawl/cli/firecrawl.md
- **Licence:** No licence detected — all rights reserved by its authors

Bundled files (2), referenced from this skill's directory:
  - `rules/install.md` — https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl/rules/install.md
  - `rules/security.md` — https://raw.githubusercontent.com/firecrawl/cli/main/skills/firecrawl/rules/security.md

_Body withheld: no licence could be detected for this skill. Read it upstream._

<!-- chapter:end slug=firecrawl -->
