Rust - Firecrawl Docs

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 firecrawlcargo add tokio --features fullcargo add serde_json

Note

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);

Analyse des fichiers envoyés#

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 navigateurlet 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 naturellet 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 cloudlet 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 authentificationlet 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.

Installation#

Utilisation#

Scraper une URL#

extraction JSON#

Analyse des fichiers envoyés#

ParseFile#

ParseOptions#

Effectuer le crawl d’un site web#

Démarrer un crawl#

Vérifier l’état du crawl#

Annuler un crawl#

Vérifier les erreurs de crawl#

Cartographier un site web#

Recherche sur le Web#

Scraping par lots#

Agent#

Session interactive liée au scraping#

Configuration#

Variable d’environnement#

Intervalles d’interrogation#

Gestion des erreurs#

`ParseFile`#

`ParseOptions`#