> ## Documentation Index
> Fetch the complete documentation index at: https://student-213fb9fc.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Rust

> Le SDK Rust de Firecrawl est une bibliothèque qui facilite le scraping et le crawling de sites web, et produit des données prêtes à l’emploi pour les modèles de langage (LLM).

<Warning>
  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.
</Warning>

<div id="installation">
  ## Installation
</div>

Pour installer le SDK Rust Firecrawl, ajoutez ce qui suit à votre `Cargo.toml` :

```yaml Rust theme={null}
# Ajoutez ceci à votre Cargo.toml
[dependencies]
firecrawl = "^1.0"
tokio = { version = "^1", features = ["full"] }
```

<div id="usage">
  ## Utilisation
</div>

Commencez par obtenir une clé API sur [firecrawl.dev](https://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 Rust theme={null}
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),
    }
}
```

<div id="scraping-a-url">
  ### Scraper une URL
</div>

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 Rust theme={null}
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),
}
```

<div id="scraping-with-extract">
  ### Extraction avec Extract
</div>

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 Rust theme={null}
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),
}
```

<div id="crawling-a-website">
  ### Explorer un site web
</div>

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 Rust theme={null}
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),
}
```

<div id="sitemap-only-crawl-v2-api">
  ### Crawl du sitemap uniquement (API v2)
</div>

Le SDK Rust cible actuellement l’API v1. Pour utiliser `sitemap: "only"`, appelez directement l’endpoint v2 :

```rust Rust theme={null}
use reqwest::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let res = client
        .post("https://api.firecrawl.dev/v2/crawl")
        .bearer_auth("fc-YOUR-API-KEY")
        .json(&json!({
            "url": "https://docs.firecrawl.dev",
            "sitemap": "only",
            "limit": 25,
        }))
        .send()
        .await?;

    println!("{}", res.text().await?);
    Ok(())
}
```

<div id="crawling-asynchronously">
  #### Exploration asynchrone
</div>

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 Rust theme={null}
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 ...
}
```

<div id="map-a-url">
  ### Cartographier une URL
</div>

Cartographier tous les liens associés à partir d’une URL de départ.

```rust Rust theme={null}
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),
}
```

<div id="error-handling">
  ## Gestion des erreurs
</div>

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>`.