`
* `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`.
```rust theme={null}
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`.
```rust theme={null}
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`.
```rust theme={null}
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`.
```rust theme={null}
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`.
```rust theme={null}
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`.
```rust theme={null}
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` :
```rust theme={null}
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`.
```rust theme={null}
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 :
```rust theme={null}
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`.
```rust theme={null}
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`.
```rust theme={null}
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 :
```rust theme={null}
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,
}
let schema = json!({
"type": "object",
"properties": {
"plans": {
"type": "array",
"items": {
"type": "object",
"properties": {
"name": { "type": "string" },
"price": { "type": "string" }
}
}
}
}
});
let result: Option = 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é.
```rust theme={null}
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 |
```rust theme={null}
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é :
```bash theme={null}
export FIRECRAWL_API_KEY=fc-YOUR-API-KEY
```
```rust theme={null}
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 :
```rust theme={null}
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`.
```rust theme={null}
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](https://www.firecrawl.dev/agent-onboarding/SKILL.md) pour obtenir des instructions d’intégration automatisée.