Firecrawl

https://docs.firecrawl.dev
Admin
Firecrawl is an API service that crawls websites and converts them into LLM-ready markdown,...
Tokens:335,872
Snippets:2,885
Trust Score:9.4
Update:2 months ago
Show doc for...
Tokens:
Raw
### Run the Brand Style Guide Generator

Source: https://docs.firecrawl.dev/developer-guides/cookbooks/brand-style-guide-generator-cookbook

Execute this command in your terminal to start the brand style guide generation process. Ensure you have the necessary dependencies installed.

```bash
npm start
```

--------------------------------

### Install and Run Mintlify CLI

Source: https://docs.firecrawl.dev/quickstart

Commands to install the Mintlify CLI globally and start a local development server for previewing documentation.

```bash
npm i -g mintlify
```

```bash
mintlify dev
```

--------------------------------

### Run globally installed server

Source: https://docs.firecrawl.dev/mcp-server/local

Start the globally installed MCP server with the required API key.

```bash
env FIRECRAWL_API_KEY=fc-YOUR-API-KEY firecrawl-mcp
```

--------------------------------

### Install Firecrawl Go SDK

Source: https://docs.firecrawl.dev/sdks/go

Command to install the Firecrawl Go SDK via go get.

```bash
go get github.com/firecrawl/firecrawl/apps/go-sdk
```

--------------------------------

### Initialize and Use Firecrawl Client

Source: https://docs.firecrawl.dev/sdks/ruby

Basic setup and usage example for scraping and crawling.

```ruby
require "firecrawl"

client = Firecrawl::Client.from_env

doc = client.scrape(
  "https://firecrawl.dev",
  Firecrawl::Models::ScrapeOptions.new(formats: ["markdown"])
)

job = client.crawl(
  "https://firecrawl.dev",
  Firecrawl::Models::CrawlOptions.new(limit: 5)
)

puts doc.markdown
puts "Crawled pages: #{job.data&.size || 0}"
```

--------------------------------

### Initialize and Use Firecrawl Client

Source: https://docs.firecrawl.dev/sdks/go

Basic setup for the Firecrawl client and examples of scraping a single page and crawling a website.

```go
package main

import (
	"context"
	"fmt"
	"log"

	firecrawl "github.com/firecrawl/firecrawl/apps/go-sdk"
	"github.com/firecrawl/firecrawl/apps/go-sdk/option"
)

func main() {
	// Create a client (reads FIRECRAWL_API_KEY from environment)
	client, err := firecrawl.NewClient()
	if err != nil {
		log.Fatal(err)
	}

	// Or provide the API key directly
	client, err = firecrawl.NewClient(
		option.WithAPIKey("fc-your-api-key"),
	)
	if err != nil {
		log.Fatal(err)
	}

	ctx := context.Background()

	// Scrape a single page
	doc, err := client.Scrape(ctx, "https://firecrawl.dev", &firecrawl.ScrapeOptions{
		Formats: []string{"markdown"},
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(doc.Markdown)

	// Crawl a website
	job, err := client.Crawl(ctx, "https://firecrawl.dev", &firecrawl.CrawlOptions{
		Limit: firecrawl.Int(5),
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Crawled pages: %d\n", len(job.Data))
}
```

--------------------------------

### Setup Cloudflare Worker Project

Source: https://docs.firecrawl.dev/quickstarts/cloudflare-workers

Initialize a new Cloudflare Worker project and install the Firecrawl SDK.

```bash
npm create cloudflare@latest my-scraper
cd my-scraper
npm install firecrawl
```

--------------------------------

### AWS Lambda Setup and Deployment

Source: https://docs.firecrawl.dev/quickstarts/aws-lambda

Commands to initialize a Node.js project, install Firecrawl, package the function with its dependencies, and deploy it to AWS Lambda using the AWS CLI. Includes setting environment variables and function configuration.

```bash
mkdir firecrawl-lambda && cd firecrawl-lambda
npm init -y
npm install firecrawl
```

```bash
zip -r function.zip index.mjs node_modules/

aws lambda create-function \
  --function-name firecrawl-scraper \
  --runtime nodejs20.x \
  --handler index.handler \
  --zip-file fileb://function.zip \
  --role arn:aws:iam::YOUR_ACCOUNT:role/lambda-role \
  --environment Variables="{FIRECRAWL_API_KEY=fc-YOUR-API-KEY}" \
  --timeout 60
```

--------------------------------

### Start Development Server

Source: https://docs.firecrawl.dev/developer-guides/cookbooks/ai-research-assistant-cookbook

Run this command to start the development server and test the basic chat functionality in your browser.

```bash
npm run dev
```

--------------------------------

### Verify Hermes Setup

Source: https://docs.firecrawl.dev/integrations/hermes

Run the verification command to confirm the setup.

```bash
hermes setup
```

--------------------------------

### Batch Process Multiple Websites

Source: https://docs.firecrawl.dev/developer-guides/cookbooks/brand-style-guide-generator-cookbook

Implement batch processing to generate brand style guides for multiple websites sequentially. This example iterates through a list of URLs, scrapes each one for branding information, and includes a placeholder for PDF generation.

```typescript
const websites = [
  "https://stripe.com",
  "https://linear.app",
  "https://vercel.com"
];

for (const site of websites) {
  const { branding } = await fc.scrape(site, { formats: ["branding"] }) as any;
  // Generate PDF for each site...
}
```

--------------------------------

### Clone and install dependencies

Source: https://docs.firecrawl.dev/contributing/guide

Download the repository and install required packages within the API directory.

```bash
git clone https://github.com/firecrawl/firecrawl.git
cd firecrawl/apps/api
pnpm install
```

--------------------------------

### Install Dependencies

Source: https://docs.firecrawl.dev/quickstarts/fastapi

Install the required packages for the FastAPI application.

```bash
pip install fastapi uvicorn firecrawl-py
```

--------------------------------

### Quick Start with Firecrawl Tools

Source: https://docs.firecrawl.dev/developer-guides/llm-sdks-and-frameworks/vercel-ai-sdk

This example demonstrates how to use the bundled FirecrawlTools() with the Vercel AI SDK to perform a sequence of actions: interact with a website, search for related information, scrape relevant pages, and summarize the findings. It uses the `generateText` function and specifies a stop condition.

```typescript
import { generateText, stepCountIs } from 'ai';
import { FirecrawlTools } from 'firecrawl-aisdk';

const { text } = await generateText({
  model: 'anthropic/claude-sonnet-4-5',
  tools: FirecrawlTools(),
  stopWhen: stepCountIs(30),
  prompt: `
    1. Use interact on Hacker News to identify the top story
    2. Search for other perspectives on the same topic
    3. Scrape the most relevant pages you found
    4. Summarize everything you found
  `,
});
```

--------------------------------

### Install Firecrawl Ruby SDK

Source: https://docs.firecrawl.dev/sdks/ruby

Installation methods using Bundler or direct gem installation.

```ruby
gem "firecrawl-sdk", "~> 1.0"
```

```bash
bundle install
```

```bash
gem install firecrawl-sdk
```

--------------------------------

### Install Laravel AI SDK

Source: https://docs.firecrawl.dev/sdks/php

Install the required package via Composer.

```bash
composer require laravel/ai
```

--------------------------------

### Basic Usage Example

Source: https://docs.firecrawl.dev/sdks/dotnet

A quick example demonstrating how to initialize the Firecrawl client and perform basic scrape and crawl operations.

```APIDOC
## Basic Usage Example

This example shows how to initialize the `FirecrawlClient` and perform a scrape and crawl operation.

```csharp
using Firecrawl;
using Firecrawl.Models;

var client = new FirecrawlClient("fc-your-api-key");

// Scrape a single page
var doc = await client.ScrapeAsync("https://firecrawl.dev",
    new ScrapeOptions { Formats = new List<object> { "markdown" } });

// Crawl a website
var job = await client.CrawlAsync("https://firecrawl.dev",
    new CrawlOptions { Limit = 5 });

Console.WriteLine(doc.Markdown);
Console.WriteLine($"Crawled pages: {job.Data?.Count ?? 0}");
```
```

--------------------------------

### Install Firecrawl SDK with Bun

Source: https://docs.firecrawl.dev/quickstarts/bun

Install the Firecrawl SDK using Bun. Ensure you have Bun 1.0+ installed.

```bash
bun add firecrawl
```

--------------------------------

### Install JavaScript dependencies

Source: https://docs.firecrawl.dev/integrations/langchain

Install the necessary community and SDK packages for LangChain JS.

```bash
npm install @langchain/community @mendable/firecrawl-js
```

--------------------------------

### Install Firecrawl CLI

Source: https://docs.firecrawl.dev/features/map

Install the Firecrawl CLI globally using npm. After installation, authenticate your account using the `firecrawl login` command.

```bash
# Install globally with npm
npm install -g firecrawl

# Authenticate (one-time setup)
firecrawl login
```

--------------------------------

### Install Praison AI tools

Source: https://docs.firecrawl.dev/integrations/praison

Install the necessary dependencies to enable tool support in Praison AI.

```bash
pip install "praisonai[tools]"
```

--------------------------------

### Install Dependencies

Source: https://docs.firecrawl.dev/developer-guides/llm-sdks-and-frameworks/openai

Install the required packages for Firecrawl and OpenAI integration.

```bash
npm install firecrawl openai zod
```

--------------------------------

### Install OpenAI Provider

Source: https://docs.firecrawl.dev/developer-guides/cookbooks/ai-research-assistant-cookbook

Install the OpenAI provider package to enable connection with OpenAI's language models.

```bash
npm install @ai-sdk/openai
```

--------------------------------

### Interactive Tool Setup

Source: https://docs.firecrawl.dev/integrations/hermes

Launch the interactive tool configuration menu.

```bash
hermes tools
```

--------------------------------

### Install and Initialize Firecrawl SDK

Source: https://docs.firecrawl.dev/sdks/node

Install the package via npm and initialize the client. An API key is optional for the free tier but recommended for higher rate limits.

```js
// npm install firecrawl

import { Firecrawl } from 'firecrawl';

const firecrawl = new Firecrawl({
  // No API key needed to get started — add one for higher rate limits:
  // apiKey: "fc-YOUR-API-KEY",
});
```

--------------------------------

### Create the .env configuration file

Source: https://docs.firecrawl.dev/contributing/self-host

Generate a minimal environment file with necessary database credentials for the initial deployment.

```bash
cat > .env <<'EOF'
USE_DB_AUTHENTICATION=false
POSTGRES_USER=postgres
POSTGRES_PASSWORD=replace-with-at-least-32-random-characters
POSTGRES_DB=postgres
EOF
```

--------------------------------

### Install Firecrawl and Google Generative AI SDK

Source: https://docs.firecrawl.dev/developer-guides/llm-sdks-and-frameworks/gemini

Install the necessary npm packages for Firecrawl and Google's Generative AI. This is the initial setup step for using Gemini with Firecrawl.

```bash
npm install firecrawl @google/genai
```

--------------------------------

### Run FastAPI Server

Source: https://docs.firecrawl.dev/quickstarts/fastapi

Start the development server using uvicorn.

```bash
uvicorn main:app --reload
```

--------------------------------

### Check Python Extraction Job Status

Source: https://docs.firecrawl.dev/features/extract

Use this method after starting an extraction job to get its current status and results. The SDK waits for completion by default if not using start methods.

```python
from firecrawl import Firecrawl

firecrawl = Firecrawl(
    api_key="fc-YOUR_API_KEY"
)

# Start an extraction job first
extract_job = firecrawl.start_extract([
    'https://docs.firecrawl.dev/*', 
    'https://firecrawl.dev/'
], prompt="Extract the company mission and features from these pages.")

# Get the status of the extraction job
job_status = firecrawl.get_extract_status(extract_job.id)

print(job_status)
# Example output:
# id=None
# status='completed'
# expires_at=datetime.datetime(...)
# success=True
# data=[{ ... }]
# error=None
# warning=None
# sources=None
```

--------------------------------

### Add Research Index Skill

Source: https://docs.firecrawl.dev/ai-onboarding

Install the research-specific index skill to an existing project setup.

```bash
npx skills add firecrawl/skills@firecrawl-research-index
```

--------------------------------

### Initialize Node.js Project

Source: https://docs.firecrawl.dev/developer-guides/cookbooks/brand-style-guide-generator-cookbook

Create a new project directory and initialize it with npm. This sets up the basic structure for your Node.js application.

```bash
mkdir brand-style-guide-generator && cd brand-style-guide-generator
npm init -y
```

--------------------------------

### Start Redis server

Source: https://docs.firecrawl.dev/contributing/guide

Launch the local Redis instance required for queue management.

```bash
redis-server
```

--------------------------------

### Asynchronous Job Initiation Response

Source: https://docs.firecrawl.dev/features/batch-scrape

Example of the JSON response returned when starting a batch scrape asynchronously.

```json
{
  "success": true,
  "id": "123-456-789",
  "url": "https://api.firecrawl.dev/v2/batch/scrape/123-456-789"
}
```

--------------------------------

### Check Node.js Extraction Job Status

Source: https://docs.firecrawl.dev/features/extract

Initiate an extraction and then poll for its status using the Node.js SDK. This example demonstrates starting a job and checking its completion.

```javascript
import { Firecrawl } from 'firecrawl';

const firecrawl = new Firecrawl({ apiKey: "fc-YOUR-API-KEY" });

const started = await firecrawl.startExtract({
  urls: ['https://docs.firecrawl.dev'],
  prompt: 'Extract title',
  schema: { type: 'object', properties: { title: { type: 'string' } }, required: ['title'] },
});

if (started.id) {
  const done = await firecrawl.getExtractStatus(started.id);
  console.log(done.status, done.data);
}
```

--------------------------------

### Extracting Data with a Prompt

Source: https://docs.firecrawl.dev/features/extract

This example demonstrates how to use the `/extract` endpoint to get structured data by providing a prompt and a schema. It's useful for research or when specific URLs are not available.

```APIDOC
## Extracting without URLs

The `/extract` endpoint now supports extracting structured data using a prompt without needing specific URLs. This is useful for research or when exact URLs are unknown. Currently in Alpha.

<CodeGroup>
  ```python Python theme={null}
  from pydantic import BaseModel

  class ExtractSchema(BaseModel):
      company_mission: str


  # Define the prompt for extraction
  prompt = 'Extract the company mission from Firecrawl\'s website.'

  # Perform the extraction
  scrape_result = firecrawl.extract(prompt=prompt, schema=ExtractSchema)

  print(scrapeResult)
  ```

  ```js Node theme={null}
  import { z } from "zod";

  // Define schema to extract contents into
  const schema = z.object({
    company_mission: z.string(),
  });

  const scrapeResult = await firecrawl.extract([], {
    prompt: "Extract the company mission from Firecrawl\'s website.",
    schema: schema
  });

  console.log(scrapeResult);
  ```

  ```bash cURL theme={null}
  curl -X POST https://api.firecrawl.dev/v2/extract \
      -H 'Content-Type: application/json' \
      -H 'Authorization: Bearer YOUR_API_KEY' \
      -d '{
        "urls": [],
        "prompt": "Extract the company mission from the Firecrawl\'s website.",
        "schema": {
          "type": "object",
          "properties": {
            "company_mission": {
              "type": "string"
            }
          },
          "required": ["company_mission"]
        }
      }'
  ```
</CodeGroup>
```

--------------------------------

### Initialize and Use Firecrawl Client

Source: https://docs.firecrawl.dev/sdks/php

Basic usage example showing client initialization from environment variables and performing scrape and crawl operations.

```php
use Firecrawl\Client\FirecrawlClient;
use Firecrawl\Models\CrawlOptions;
use Firecrawl\Models\ScrapeOptions;

$client = FirecrawlClient::fromEnv();

$doc = $client->scrape(
    'https://firecrawl.dev',
    ScrapeOptions::with(formats: ['markdown'])
);

$crawl = $client->crawl(
    'https://firecrawl.dev',
    CrawlOptions::with(limit: 5)
);

echo $doc->getMarkdown();
echo 'Crawled pages: ' . count($crawl->getData());
```

--------------------------------

### Use Default FirecrawlTools with generateText

Source: https://docs.firecrawl.dev/developer-guides/llm-sdks-and-frameworks/vercel-ai-sdk

Initialize FirecrawlTools to get default tools and a system prompt for `generateText`. This setup allows the AI to answer questions with citations by leveraging web search and scraping.

```typescript
import { generateText, stepCountIs } from 'ai';
import { FirecrawlTools } from 'firecrawl-aisdk';

const tools = FirecrawlTools();

const { text } = await generateText({
  model: 'anthropic/claude-sonnet-4-5',
  system: `${tools.systemPrompt}\n\nAnswer with citations when possible.`, 
  tools,
  stopWhen: stepCountIs(20),
  prompt: 'Find the current Firecrawl pricing page and explain the available plans.',
});
```

--------------------------------

### Test Firecrawl Laravel Integration with cURL

Source: https://docs.firecrawl.dev/quickstarts/laravel

Use cURL commands to test the search, scrape, and interact API endpoints after starting the Laravel development server. These examples demonstrate how to send JSON payloads.

```bash
php artisan serve

# Search the web
curl -X POST http://localhost:8000/api/search \
  -H "Content-Type: application/json" \
  -d '{"query": "firecrawl web scraping"}'

# Scrape a page
curl -X POST http://localhost:8000/api/scrape \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com"}'

# Interact with a page
curl -X POST http://localhost:8000/api/interact \
  -H "Content-Type: application/json" \
  -d '{"url": "https://www.amazon.com", "prompt": "Search for iPhone 16 Pro Max", "followUp": "Click on the first result and tell me the price"}'

```

--------------------------------

### JSON Schema for Structured Output

Source: https://docs.firecrawl.dev/features/llm-extract

Define the desired structured output using JSON Schema. This example specifies properties for product name, installation type with an enum, and flow rate, including null handling.

```json
{
  "type": "object",
  "properties": {
    "product_name": {
      "type": ["string", "null"],
      "description": "Full descriptive product name as shown on the page. Return null if not found."
    },
    "installation_type": {
      "type": ["string", "null"],
      "description": "Installation type from the Specifications section. Return null if not found.",
      "enum": ["Deck-mount", "Wall-mount", "Countertop", "Drop-in", "Undermount"]
    },
    "flow_rate_gpm": {
      "type": ["string", "null"],
      "description": "Flow rate in GPM from the Specifications section. Return null if not found."
    }
  }
}
```

--------------------------------

### Build and start the Firecrawl stack

Source: https://docs.firecrawl.dev/contributing/self-host

Initialize the services in the background and verify that all containers are running correctly.

```bash
docker compose up --build -d
docker compose ps --all
```

--------------------------------

### Scrape and Extract JSON Data with Node.js

Source: https://docs.firecrawl.dev/features/llm-extract

This Node.js example shows how to scrape a URL and extract data into a Zod schema. Install the 'firecrawl' and 'zod' packages. An API key can be added for increased rate limits.

```javascript
import { Firecrawl } from "firecrawl";
import { z } from "zod";

const app = new Firecrawl({
  // No API key needed to get started — add one for higher rate limits:
  // apiKey: "fc-YOUR_API_KEY",
});

// Define schema to extract contents into
const schema = z.object({
  company_mission: z.string(),
  supports_sso: z.boolean(),
  is_open_source: z.boolean(),
  is_in_yc: z.boolean()
});

const result = await app.scrape("https://firecrawl.dev", {
  formats: [{
    type: "json",
    schema: schema
  }],
});

console.log(result);
```

--------------------------------

### Installation and Configuration

Source: https://docs.firecrawl.dev/sdks/elixir

Instructions on how to add the Firecrawl Elixir SDK to your project and configure your API key.

```APIDOC
## Installation

Add `firecrawl` to your list of dependencies in `mix.exs` and configure your API key:

```elixir
# Add to mix.exs
{:firecrawl, "~> 1.0"}

# Then configure your API key in config.exs
config :firecrawl, api_key: "fc-YOUR-API-KEY"
```

Or pass the API key per-request:

```elixir
Firecrawl.scrape_and_extract_from_url([url: "https://example.com"], api_key: "fc-YOUR-API-KEY")
```
```

--------------------------------

### Async Operations with Firecrawl Python SDK

Source: https://docs.firecrawl.dev/sdks/python

Use the AsyncFirecrawl class for non-blocking operations. This example demonstrates scraping, searching, starting and checking crawl status, and batch scraping with specified formats and polling intervals.

```python
import asyncio
from firecrawl import AsyncFirecrawl

async def main():
    firecrawl = AsyncFirecrawl(api_key="fc-YOUR-API-KEY")

    # Scrape
    doc = await firecrawl.scrape("https://firecrawl.dev", formats=["markdown"])  # type: ignore[arg-type]
    print(doc.get("markdown"))

    # Search
    results = await firecrawl.search("firecrawl", limit=2)
    print(results.get("web", []))

    # Crawl (start + status)
    started = await firecrawl.start_crawl("https://docs.firecrawl.dev", limit=3)
    status = await firecrawl.get_crawl_status(started.id)
    print(status.status)

    # Batch scrape (wait)
    job = await firecrawl.batch_scrape([
        "https://firecrawl.dev",
        "https://docs.firecrawl.dev",
    ], formats=["markdown"], poll_interval=1, timeout=60)
    print(job.status, job.completed, job.total)

asyncio.run(main())
```

--------------------------------

### Configure Firecrawl MCP with Google ADK

Source: https://docs.firecrawl.dev/developer-guides/llm-sdks-and-frameworks/google-adk

Set up an agent using either a remote streamable HTTP server or a local stdio-based MCP server. Ensure the FIRECRAWL_API_KEY is set in the environment and Node.js 22+ is installed for local setups.

```python
import os

from google.adk.agents.llm_agent import Agent
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPServerParams
from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset

FIRECRAWL_API_KEY = os.environ["FIRECRAWL_API_KEY"]

root_agent = Agent(
    model="gemini-2.5-pro",
    name="firecrawl_agent",
    description='A helpful assistant for scraping websites with Firecrawl',
    instruction='Help the user search for website content',
    tools=[
        MCPToolset(
            connection_params=StreamableHTTPServerParams(
                url="https://mcp.firecrawl.dev/v2/mcp",
                headers={"Authorization": f"Bearer {FIRECRAWL_API_KEY}"},
            ),
        )
    ],
)
```

```python
import os

from google.adk.agents.llm_agent 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

root_agent = Agent(
    model='gemini-2.5-pro',
    name='firecrawl_agent',
    description='A helpful assistant for scraping websites with Firecrawl',
    instruction='Help the user search for website content',
    tools=[
        MCPToolset(
            connection_params=StdioConnectionParams(
                server_params = StdioServerParameters(
                    command='npx',
                    args=[
                        "-y",
                        "firecrawl-mcp@3.23.7",
                    ],
                    env={
                        "FIRECRAWL_API_KEY": os.environ["FIRECRAWL_API_KEY"],
                    }
                ),
                timeout=30,
            ),
        )
    ],
)
```

--------------------------------

### Crawl Started Webhook Event

Source: https://docs.firecrawl.dev/api-reference/endpoint/webhook-crawl-started

This webhook event is sent when a crawl job begins processing. For detailed payload examples, configuration options, and information on retry behavior, please refer to the Webhook Event Types and Webhook Overview documentation.

```APIDOC
## Crawl Started Webhook Event

### Description
Webhook event sent when a crawl job begins processing.

### Further Information
For payload examples, configuration, and retry behavior, see [Webhook Event Types](/webhooks/events#crawlstarted) and [Webhook Overview](/webhooks/overview).
```

--------------------------------

### Run and Test Application

Source: https://docs.firecrawl.dev/quickstarts/aspnet-core

Commands to execute the application and perform tests.

```bash
dotnet run
```

--------------------------------

### Supabase Edge Function for Page Interaction

Source: https://docs.firecrawl.dev/quickstarts/supabase-edge-functions

Develop a Supabase Edge Function to interact with a web page, including scraping, performing actions like searching and clicking, and extracting dynamic content. This example scrapes Amazon, searches for a product, gets its price, and then stops the interaction.

```typescript
import Firecrawl from "npm:firecrawl";

const firecrawl = new Firecrawl({
  apiKey: Deno.env.get("FIRECRAWL_API_KEY"),
});

Deno.serve(async (_req) => {
  const result = await firecrawl.scrape("https://www.amazon.com", {
    formats: ["markdown"],
  });
  const scrapeId = result.metadata?.scrapeId;

  await firecrawl.interact(scrapeId, {
    prompt: "Search for iPhone 16 Pro Max",
  });
  const response = await firecrawl.interact(scrapeId, {
    prompt: "Click on the first result and tell me the price",
  });
  console.log(response.output);

  await firecrawl.stopInteraction(scrapeId);

  return new Response(JSON.stringify({ output: response.output }), {
    headers: { "Content-Type": "application/json" },
  });
});
```

--------------------------------

### Initialize Firecrawl Client

Source: https://docs.firecrawl.dev/features/crawl

Setup the Firecrawl client for Python, Node.js, or the CLI.

```python
# pip install firecrawl-py

from firecrawl import Firecrawl

firecrawl = Firecrawl(
  # No API key needed to get started — add one for higher rate limits:
  # api_key="fc-YOUR-API-KEY",
)
```

```js
// npm install firecrawl

import { Firecrawl } from 'firecrawl';

const firecrawl = new Firecrawl({
  // No API key needed to get started — add one for higher rate limits:
  // apiKey: "fc-YOUR-API-KEY",
});
```

```bash
# Install globally with npm
npm install -g firecrawl

# Authenticate (one-time setup)
firecrawl login
```

--------------------------------

### Configure Environment and Initialize Client

Source: https://docs.firecrawl.dev/quickstarts/nodejs

Set the API key via environment variable and initialize the Firecrawl client.

```bash
export FIRECRAWL_API_KEY=fc-YOUR-API-KEY
```

```javascript
const app = new Firecrawl();
```

--------------------------------

### Install Firecrawl SDK

Source: https://docs.firecrawl.dev/quickstarts/mastra

Install the Firecrawl SDK using npm. Ensure you have Node.js 22.13+ installed.

```bash
npm install firecrawl
```

--------------------------------

### Start MCP server via stdio

Source: https://docs.firecrawl.dev/mcp-server/local

Launch the server as a local process using stdio transport.

```bash
env FIRECRAWL_API_KEY=fc-YOUR-API-KEY \
  npx -y firecrawl-mcp@3.23.7
```

--------------------------------

### Example Search Prompt

Source: https://docs.firecrawl.dev/quickstarts/opencode

Use this prompt within OpenCode to search for information.

```text
Search the web for the latest Bun release notes and summarize the sources.
```

--------------------------------

### Create Next.js Project

Source: https://docs.firecrawl.dev/developer-guides/cookbooks/ai-research-assistant-cookbook

Initialize a new Next.js application with TypeScript, ESLint, Tailwind CSS, and the App Router. Navigate into the created project directory.

```bash
npx create-next-app@latest ai-sdk-firecrawl && cd ai-sdk-firecrawl
```

--------------------------------

### Run Mastra Dev Server

Source: https://docs.firecrawl.dev/quickstarts/mastra

Start the Mastra development server to test your agent in Mastra Studio. Access Mastra Studio via the provided URL.

```bash
mastra dev
```

--------------------------------

### Install Firecrawl SDK

Source: https://docs.firecrawl.dev/quickstarts/django

Install the required Python package for Firecrawl.

```bash
pip install firecrawl-py
```

--------------------------------

### View CLI Configuration

Source: https://docs.firecrawl.dev/sdks/cli

Displays the current configuration settings and authentication status.

```bash
firecrawl view-config
```

--------------------------------

### Install Dependencies for LangGraph and Firecrawl

Source: https://docs.firecrawl.dev/developer-guides/llm-sdks-and-frameworks/langgraph

Install the necessary npm packages for LangGraph, OpenAI, and Firecrawl. Ensure you have Node.js version 20 or later, or install dotenv for older versions.

```bash
npm install @langchain/langgraph @langchain/openai firecrawl
```

```bash
FIRECRAWL_API_KEY=your_firecrawl_key
OPENAI_API_KEY=your_openai_key
```

--------------------------------

### Run Bun Server

Source: https://docs.firecrawl.dev/quickstarts/bun

Execute the Bun server script to start the web scraping and search service.

```bash
bun run index.ts
```

--------------------------------

### Install Express and Firecrawl

Source: https://docs.firecrawl.dev/quickstarts/express

Install the necessary npm packages for your Express.js project.

```bash
npm install express firecrawl
```
Tokens:
Raw