Ce SDK utilise actuellement la version v1 de l’API Firecrawl, qui n’est pas la plus récente (la v2 est disponible). Certaines fonctionnalités et améliorations peuvent n’être disponibles qu’en v2.

​
Installation

Pour installer le SDK Rust Firecrawl, ajoutez ce qui suit à votre Cargo.toml :
Rust
# Ajoutez ceci à votre Cargo.toml
[dependencies]
firecrawl = "^1.0"
tokio = { version = "^1", features = ["full"] }

​
Utilisation

Commencez par obtenir une clé API sur firecrawl.dev. Initialisez ensuite FirecrawlApp. Vous pourrez alors accéder à des fonctions comme FirecrawlApp::scrape_url, qui vous permettent d’utiliser notre API. Voici un exemple d’utilisation du SDK en Rust :
Rust
use firecrawl::{crawl::{CrawlOptions, CrawlScrapeOptions, CrawlScrapeFormats}, FirecrawlApp, scrape::{ScrapeOptions, ScrapeFormats}};

#[tokio::main]
async fn main() {
    // Initialiser FirecrawlApp avec la clé API
    let app = FirecrawlApp::new("fc-YOUR_API_KEY").expect("Échec de l’initialisation de FirecrawlApp");

    // Scraper une URL
    let options = ScrapeOptions {
        formats vec! [ ScrapeFormats::Markdown, ScrapeFormats::HTML ].into(),
        ..Default::default()
    };

    let scrape_result = app.scrape_url("https://firecrawl.dev", options).await;

    match scrape_result {
        Ok(data) => println!("Résultat du scraping :\n{}", data.markdown.unwrap()),
        Err(e) => eprintln!("Échec du mapping : {}", e),
    }

    // Crawler un site web
    let crawl_options = CrawlOptions {
        scrape_options: CrawlScrapeOptions {
            formats: vec![ CrawlScrapeFormats::Markdown, CrawlScrapeFormats::HTML ].into(),
            ..Default::default()
        }.into(),
        limit: 100.into(),
        ..Default::default()
    };

    let crawl_result = app
        .crawl_url("https://mendable.ai", crawl_options)
        .await;

    match crawl_result {
        Ok(data) => println!("Résultat du crawl ({} crédits utilisés) :\n{:#?}", data.credits_used, data.data),
        Err(e) => eprintln!("Échec du crawl : {}", e),
    }
}

​
Scraper une URL

Pour scraper une seule URL, utilisez la méthode scrape_url. Elle prend l’URL en paramètre et renvoie les données scrappées sous forme de Document.
Rust
let options = ScrapeOptions {
    formats vec! [ ScrapeFormats::Markdown, ScrapeFormats::HTML ].into(),
    ..Default::default()
};

let scrape_result = app.scrape_url("https://firecrawl.dev", options).await;

match scrape_result {
    Ok(data) => println!("Résultat du scraping :\n{}", data.markdown.unwrap()),
    Err(e) => eprintln!("Échec du scraping : {}", e),
}

​
Extraction avec Extract

Avec Extract, vous pouvez facilement extraire des données structurées à partir de n’importe quelle URL. Spécifiez votre schéma au format JSON Schema en utilisant la macro serde_json::json!.
Rust
let json_schema = json!({
    "type": "object",
    "properties": {
        "top": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "title": {"type": "string"},
                    "points": {"type": "number"},
                    "by": {"type": "string"},
                    "commentsURL": {"type": "string"}
                },
                "required": ["title", "points", "by", "commentsURL"]
            },
            "minItems": 5,
            "maxItems": 5,
            "description": "Top 5 actualités sur Hacker News"
        }
    },
    "required": ["top"]
});

let llm_extraction_options = ScrapeOptions {
    formats: vec![ ScrapeFormats::Json ].into(),
    jsonOptions: ExtractOptions {
        schema: json_schema.into(),
        ..Default::default()
    }.into(),
    ..Default::default()
};

let llm_extraction_result = app
    .scrape_url("https://news.ycombinator.com", llm_extraction_options)
    .await;

match llm_extraction_result {
    Ok(data) => println!("Résultat de l’extraction LLM :\n{:#?}", data.extract.unwrap()),
    Err(e) => eprintln!("Échec de l’extraction LLM : {}", e),
}

​
Explorer un site web

Pour explorer un site web, utilisez la méthode crawl_url. L’appel attendra la fin de l’exploration, ce qui peut prendre du temps selon l’URL de départ et les options choisies.
Rust
let crawl_options = CrawlOptions {
    scrape_options: CrawlScrapeOptions {
        formats: vec![ CrawlScrapeFormats::Markdown, CrawlScrapeFormats::HTML ].into(),
        ..Default::default()
    }.into(),
    limit: 100.into(),
    ..Default::default()
};

let crawl_result = app
    .crawl_url("https://mendable.ai", crawl_options)
    .await;

match crawl_result {
    Ok(data) => println!("Résultat du crawl ({} crédits consommés) :\n{:#?}", data.credits_used, data.data),
    Err(e) => eprintln!("Échec du crawl : {}", e),
}

​
Exploration asynchrone

Pour lancer une exploration sans attendre le résultat, utilisez la méthode crawl_url_async. Elle accepte les mêmes paramètres, mais renvoie une structure CrawlAsyncRespone contenant l’ID de l’exploration. Vous pouvez utiliser cet ID avec la méthode check_crawl_status pour vérifier l’état à tout moment. Notez que les explorations terminées sont supprimées après 24 heures.
Rust
let crawl_id = app.crawl_url_async("https://mendable.ai", None).await?.id;

// ... later ...

let status = app.check_crawl_status(crawl_id).await?;

if status.status == CrawlStatusTypes::Completed {
    println!("L’exploration est terminée : {:#?}", status.data);
} else {
    // ... attendre encore un peu ...
}

​
Cartographier une URL

Cartographier tous les liens associés à partir d’une URL de départ.
Rust
let map_result = app.map_url("https://firecrawl.dev", None).await;

match map_result {
    Ok(data) => println!("URLs cartographiées : {:#?}", data),
    Err(e) => eprintln!("Échec du mappage : {}", e),
}

​
Gestion des erreurs

Le SDK gère les erreurs renvoyées par l’API Firecrawl et par nos dépendances, et les regroupe dans l’énumération FirecrawlError, qui implémente Error, Debug et Display. Toutes nos méthodes renvoient un Result<T, FirecrawlError>.