Rust

Le SDK Rust de Firecrawl est un wrapper de l’API Firecrawl qui vous permet de convertir facilement des sites web en markdown.

Installation

Le SDK Rust officiel est maintenu dans le monorepo de Firecrawl à l’emplacement apps/rust-sdk.

Pour installer le SDK Rust de Firecrawl, ajoutez la dépendance depuis crates.io:

[dependencies]
firecrawl = "2"
tokio = { version = "1", features = ["full"] }
serde_json = "1"

Ou installez-le via Cargo :

cargo add firecrawl
cargo add tokio --features full
cargo add serde_json

Rust 1.70 ou version ultérieure est requis.

Utilisation

Obtenez une clé API depuis firecrawl.dev
Définissez la clé API dans une variable d’environnement nommée FIRECRAWL_API_KEY, ou passez-la directement à Client::new(...)

Scrapez une page et affichez son markdown :

use firecrawl::{Client, ScrapeOptions, Format};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new("fc-YOUR-API-KEY")?;

    let doc = client.scrape(
        "https://firecrawl.dev",
        ScrapeOptions {
            formats: Some(vec![Format::Markdown]),
            ..Default::default()
        },
    ).await?;

    println!("{}", doc.markdown.unwrap_or_default());
    Ok(())
}

Les sections ci-dessous portent sur le crawl, le mapping, la recherche et les autres méthodes du SDK.

Scraper une URL

Pour scraper une seule URL, utilisez la méthode scrape.

use firecrawl::{Client, ScrapeOptions, Format};

let doc = client.scrape(
    "https://firecrawl.dev",
    ScrapeOptions {
        formats: Some(vec![Format::Markdown, Format::Html]),
        only_main_content: Some(true),
        wait_for: Some(5000),
        ..Default::default()
    },
).await?;

println!("{}", doc.markdown.unwrap_or_default());
if let Some(meta) = &doc.metadata {
    println!("{:?}", meta.title);
}

extraction JSON

Extrayez un JSON structuré à l’aide de scrape_with_schema :

use firecrawl::Client;
use serde_json::json;

let schema = json!({
    "type": "object",
    "properties": {
        "name": { "type": "string" },
        "price": { "type": "number" }
    }
});

let data = client.scrape_with_schema(
    "https://example.com/product",
    schema,
    Some("Extract the product name and price"),
).await?;

println!("{}", serde_json::to_string_pretty(&data)?);

Ou configurez directement l’extraction JSON via ScrapeOptions :

use firecrawl::{Client, ScrapeOptions, Format, JsonOptions};
use serde_json::json;

let doc = client.scrape(
    "https://example.com/product",
    ScrapeOptions {
        formats: Some(vec![Format::Json]),
        json_options: Some(JsonOptions {
            schema: Some(json!({
                "type": "object",
                "properties": {
                    "name": { "type": "string" },
                    "price": { "type": "number" }
                }
            })),
            prompt: Some("Extract the product name and price".to_string()),
            ..Default::default()
        }),
        ..Default::default()
    },
).await?;

println!("{:?}", doc.json);

Utilisez parse pour envoyer un fichier local (.html, .htm, .pdf, .docx, .doc, .odt, .rtf, .xlsx, .xls) en multipart/form-data vers /v2/parse. Le point de terminaison renvoie un Document avec les formats demandés.

ParseOptions omet intentionnellement les champs propres au scrape que /v2/parse rejette (tels que actions, waitFor, location, mobile, screenshot, branding et changeTracking).

Créez un ParseFile à partir d’octets en mémoire ou directement depuis un chemin :

use firecrawl::{Client, ParseFile, ParseFormat, ParseOptions};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new("fc-YOUR-API-KEY")?;

    let file = ParseFile::from_bytes(
        "upload.html",
        b"<!DOCTYPE html><html><body><h1>Rust Parse</h1></body></html>".to_vec(),
    )
    .with_content_type("text/html");

    let options = ParseOptions {
        formats: Some(vec![ParseFormat::Markdown, ParseFormat::Html]),
        only_main_content: Some(true),
        ..Default::default()
    };

    let doc = client.parse(file, Some(options)).await?;
    println!("{}", doc.markdown.unwrap_or_default());
    Ok(())
}

Ou lisez le fichier depuis le disque et n’indiquez pas d’options :

use firecrawl::{Client, ParseFile};

let client = Client::new("fc-YOUR-API-KEY")?;
let file = ParseFile::from_path("./report.pdf")?;

let doc = client.parse(file, None).await?;
println!("{}", doc.markdown.unwrap_or_default());

`ParseFile`

Constructeur	Description
`ParseFile::from_bytes(filename, bytes)`	Créer à partir d’un nom de fichier et d’octets en mémoire
`ParseFile::from_path(path)`	Lire les octets depuis le disque et en déduire le nom de fichier
`.with_content_type(content_type)`	Ajouter une indication de type MIME (p. ex. `text/html`, `application/pdf`)

`ParseOptions`

Champs pris en charge (tous facultatifs, avec des noms en camelCase dans la requête) :

formats: Vec<ParseFormat> — au choix parmi Markdown, Html, RawHtml, Links, Images, Summary, Json, Attributes
only_main_content: bool
include_tags: Vec<String> / exclude_tags: Vec<String>
headers: HashMap<String, String>
timeout: u32 (ms)
parsers: Vec<ParserConfig> (par ex. configuration de l’analyseur PDF)
skip_tls_verification: bool
remove_base64_images: bool
fast_mode: bool
block_ads: bool
proxy: ParseProxyType (Basic ou Auto)
json_options: JsonOptions
attribute_selectors: Vec<AttributeSelector>
zero_data_retention: bool
integration: String, origin: String, use_mock: String

Effectuer le crawl d’un site web

Pour effectuer le crawl d’un site web et attendre la fin de l’opération, utilisez crawl.

use firecrawl::{Client, CrawlOptions, ScrapeOptions, Format};

let job = client.crawl(
    "https://firecrawl.dev",
    CrawlOptions {
        limit: Some(50),
        max_discovery_depth: Some(3),
        scrape_options: Some(ScrapeOptions {
            formats: Some(vec![Format::Markdown]),
            ..Default::default()
        }),
        ..Default::default()
    },
).await?;

println!("Status: {:?}", job.status);
println!("Progress: {}/{}", job.completed, job.total);

for page in &job.data {
    if let Some(meta) = &page.metadata {
        println!("{:?}", meta.source_url);
    }
}

Démarrer un crawl

Démarrez une tâche sans attendre à l’aide de start_crawl.

use firecrawl::{Client, CrawlOptions};

let start = client.start_crawl(
    "https://firecrawl.dev",
    CrawlOptions {
        limit: Some(100),
        ..Default::default()
    },
).await?;

println!("Job ID: {}", start.id);

Vérifier l’état du crawl

Suivez la progression du crawl avec get_crawl_status.

let status = client.get_crawl_status(&start.id).await?;
println!("Status: {:?}", status.status);
println!("Progress: {}/{}", status.completed, status.total);

Annuler un crawl

Annulez un crawl en cours avec cancel_crawl.

let result = client.cancel_crawl(&start.id).await?;
println!("{:?}", result);

Vérifier les erreurs de crawl

Obtenez les erreurs d’une tâche de crawl avec get_crawl_errors.

let errors = client.get_crawl_errors(&start.id).await?;
println!("{:?}", errors);

Cartographier un site web

Découvrez les liens d’un site à l’aide de map.

use firecrawl::{Client, MapOptions};

let response = client.map(
    "https://firecrawl.dev",
    MapOptions {
        limit: Some(100),
        search: Some("blog".to_string()),
        ..Default::default()
    },
).await?;

for link in &response.links {
    println!("{} - {}", link.url, link.title.as_deref().unwrap_or(""));
}

Pour obtenir un résultat plus simple avec uniquement des URL, utilisez map_urls :

let urls = client.map_urls("https://firecrawl.dev", None).await?;
for url in &urls {
    println!("{}", url);
}

Recherche sur le Web

Lancez une recherche avec des paramètres facultatifs à l’aide de search.

use firecrawl::{Client, SearchOptions};

let results = client.search(
    "firecrawl web scraping",
    SearchOptions {
        limit: Some(10),
        ..Default::default()
    },
).await?;

if let Some(web) = results.data.web {
    for item in web {
        match item {
            firecrawl::SearchResultOrDocument::WebResult(r) => {
                println!("{} - {}", r.url, r.title.unwrap_or_default());
            }
            firecrawl::SearchResultOrDocument::Document(d) => {
                println!("{}", d.markdown.unwrap_or_default());
            }
        }
    }
}

Pour une méthode utilitaire qui renvoie directement les documents extraits :

let docs = client.search_and_scrape("firecrawl web scraping", 5).await?;
for doc in &docs {
    println!("{}", doc.markdown.as_deref().unwrap_or(""));
}

Scraping par lots

Scrapez plusieurs URL en parallèle avec batch_scrape.

use firecrawl::{Client, BatchScrapeOptions, ScrapeOptions, Format};

let urls = vec![
    "https://firecrawl.dev".to_string(),
    "https://firecrawl.dev/blog".to_string(),
];

let job = client.batch_scrape(
    urls,
    BatchScrapeOptions {
        options: Some(ScrapeOptions {
            formats: Some(vec![Format::Markdown]),
            ..Default::default()
        }),
        ..Default::default()
    },
).await?;

for doc in &job.data {
    println!("{}", doc.markdown.as_deref().unwrap_or(""));
}

Agent

Lancez un agent basé sur l’IA avec agent.

use firecrawl::{Client, AgentOptions};

let result = client.agent(
    AgentOptions {
        prompt: "Find the pricing plans for Firecrawl and compare them".to_string(),
        ..Default::default()
    },
).await?;

println!("{:?}", result.data);

Avec un schéma JSON pour une sortie structurée :

use firecrawl::{Client, AgentOptions, AgentModel};
use serde::Deserialize;
use serde_json::json;

#[derive(Debug, Deserialize)]
struct PricingPlan {
    name: String,
    price: String,
}

#[derive(Debug, Deserialize)]
struct PricingData {
    plans: Vec<PricingPlan>,
}

let schema = json!({
    "type": "object",
    "properties": {
        "plans": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "name": { "type": "string" },
                    "price": { "type": "string" }
                }
            }
        }
    }
});

let result: Option<PricingData> = client.agent_with_schema(
    vec!["https://firecrawl.dev".to_string()],
    "Extract pricing plan details",
    schema,
).await?;

if let Some(data) = result {
    for plan in &data.plans {
        println!("{}: {}", plan.name, plan.price);
    }
}

Session interactive liée au scraping

Utilisez l’ID d’une tâche de scraping pour exécuter ensuite du code dans le navigateur, dans le même contexte :

interact(...) exécute du code ou des prompts dans la session de navigateur liée au scraping.
stop_interaction(...) met fin à la session interactive lorsque vous avez terminé.

use firecrawl::{Client, ScrapeExecuteOptions, ScrapeExecuteLanguage};

let scrape_job_id = "550e8400-e29b-41d4-a716-446655440000";

// Exécuter du code dans la session de navigateur
let run = client.interact(
    scrape_job_id,
    ScrapeExecuteOptions {
        code: Some("console.log(await page.title())".to_string()),
        language: Some(ScrapeExecuteLanguage::Node),
        timeout: Some(60),
        ..Default::default()
    },
).await?;

println!("{:?}", run.stdout);

// Ou utiliser un prompt en langage naturel
let run = client.interact(
    scrape_job_id,
    ScrapeExecuteOptions {
        prompt: Some("Click the pricing tab and summarize the plans".to_string()),
        ..Default::default()
    },
).await?;

// Arrêter la session une fois terminé
client.stop_interaction(scrape_job_id).await?;

Configuration

Client::new(...) et Client::new_selfhosted(...) créent un client.

Option	Description
`Client::new(api_key)`	Crée un client pour le service cloud de Firecrawl (`https://api.firecrawl.dev`)
`Client::new_selfhosted(api_url, api_key)`	Crée un client pour une instance Firecrawl auto-hébergée

use firecrawl::Client;

// Service cloud
let client = Client::new("fc-your-api-key")?;

// Auto-hébergé
let client = Client::new_selfhosted(
    "http://localhost:3002",
    Some("fc-your-api-key"),
)?;

// Auto-hébergé sans authentification
let client = Client::new_selfhosted(
    "http://localhost:3002",
    None::<&str>,
)?;

Variable d’environnement

Définissez la variable d’environnement FIRECRAWL_API_KEY au lieu de fournir directement la clé :

export FIRECRAWL_API_KEY=fc-YOUR-API-KEY

let api_key = std::env::var("FIRECRAWL_API_KEY")
    .expect("FIRECRAWL_API_KEY must be set");
let client = Client::new(api_key)?;

Intervalles d’interrogation

Les méthodes synchrones (crawl, batch_scrape, agent) interrogent le statut jusqu’à la fin du traitement. Vous pouvez personnaliser l’intervalle d’interrogation via la structure options :

use firecrawl::CrawlOptions;

let options = CrawlOptions {
    limit: Some(50),
    poll_interval: Some(3000), // Interroger toutes les 3 secondes (par défaut : 2000ms)
    ..Default::default()
};

Gestion des erreurs

Le SDK utilise l’énumération FirecrawlError, qui implémente Error, Debug et Display. Toutes les méthodes renvoient Result<T, FirecrawlError>.

use firecrawl::{Client, FirecrawlError};

match client.scrape("https://example.com", None).await {
    Ok(doc) => println!("{}", doc.markdown.unwrap_or_default()),
    Err(FirecrawlError::HttpRequestFailed(action, status, msg)) => {
        eprintln!("HTTP {}: {} ({})", status, msg, action);
    }
    Err(FirecrawlError::APIError(action, api_err)) => {
        eprintln!("API error ({}): {}", action, api_err.error);
    }
    Err(FirecrawlError::JobFailed(msg)) => {
        eprintln!("Job failed: {}", msg);
    }
    Err(FirecrawlError::Misuse(msg)) => {
        eprintln!("SDK misuse: {}", msg);
    }
    Err(e) => eprintln!("Error: {}", e),
}

Êtes-vous un agent IA qui a besoin d’une clé API pour Firecrawl ? Consultez firecrawl.dev/agent-onboarding/SKILL.md pour obtenir des instructions d’intégration automatisée.