Rust SDK | Evocrawl

Installation

Le SDK Rust officiel est maintenu dans le monorepo de Evocrawl à l’emplacement apps/rust-sdk. Pour installer le SDK Rust de Evocrawl, ajoutez la dépendance depuis crates.io:

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

Ou installez-le via Cargo :

cargo add evocrawl
cargo add tokio --features full
cargo add serde_json

Rust 1.70 ou version ultérieure est requis.

Utilisation

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

Voici un exemple rapide avec le SDK :

use evocrawl::{Client, CrawlOptions, 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://evocrawl.com",
        ScrapeOptions {
            formats: Some(vec![Format::Markdown]),
            ..Default::default()
        },
    ).await?;

    let job = client.crawl(
        "https://evocrawl.com",
        CrawlOptions {
            limit: Some(5),
            ..Default::default()
        },
    ).await?;

    println!("{}", doc.markdown.unwrap_or_default());
    println!("Crawled pages: {}", job.data.len());
    Ok(())
}

Scraper une URL

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

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

let doc = client.scrape(
    "https://evocrawl.com",
    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 evocrawl::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 evocrawl::{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);

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 evocrawl::{Client, CrawlOptions, ScrapeOptions, Format};

let job = client.crawl(
    "https://evocrawl.com",
    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 evocrawl::{Client, CrawlOptions};

let start = client.start_crawl(
    "https://evocrawl.com",
    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 evocrawl::{Client, MapOptions};

let response = client.map(
    "https://evocrawl.com",
    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://evocrawl.com", 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 evocrawl::{Client, SearchOptions};

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

if let Some(web) = results.data.web {
    for item in web {
        match item {
            evocrawl::SearchResultOrDocument::WebResult(r) => {
                println!("{} - {}", r.url, r.title.unwrap_or_default());
            }
            evocrawl::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("evocrawl 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 evocrawl::{Client, BatchScrapeOptions, ScrapeOptions, Format};

let urls = vec![
    "https://evocrawl.com".to_string(),
    "https://evocrawl.com/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 evocrawl::{Client, AgentOptions};

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

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

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

use evocrawl::{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://evocrawl.com".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 evocrawl::{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 Evocrawl (`https://api.evocrawl.com`)
`Client::new_selfhosted(api_url, api_key)`	Crée un client pour une instance Evocrawl auto-hébergée

use evocrawl::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 EVOCRAWL_API_KEY au lieu de fournir directement la clé :

export EVOCRAWL_API_KEY=fc-YOUR-API-KEY

let api_key = std::env::var("EVOCRAWL_API_KEY")
    .expect("EVOCRAWL_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 evocrawl::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 EvocrawlError, qui implémente Error, Debug et Display. Toutes les méthodes renvoient Result<T, EvocrawlError>.

use evocrawl::{Client, EvocrawlError};

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

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

Global

Officiel

Rust

Installation

Utilisation

Scraper une URL

extraction JSON

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

​Installation

​Utilisation

​Scraper une URL

​extraction JSON

​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

Installation

Utilisation

Scraper une URL

extraction JSON

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