> ## Documentation Index
> Fetch the complete documentation index at: https://docs.evocrawl.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Rust

> El SDK de Rust de Evocrawl es un envoltorio para la API de Evocrawl que te permite convertir sitios web a markdown fácilmente.

<div id="installation">
  ## Instalación
</div>

El SDK oficial de Rust está alojado en el monorepo de Evocrawl, en [apps/rust-sdk](https://github.com/superaihuman/evocrawl/tree/main/apps/rust-sdk).

Para instalar el SDK de Rust de Evocrawl, añade la dependencia desde [crates.io](https://crates.io/crates/evocrawl):

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

O instálalo con Cargo:

```bash theme={null}
cargo add evocrawl
cargo add tokio --features full
cargo add serde_json
```

<Note>Requiere Rust 1.70 o una versión posterior.</Note>

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

1. Obtén una clave de API de [evocrawl.dev](https://evocrawl.com)
2. Configura la clave de API como una variable de entorno llamada `EVOCRAWL_API_KEY` o pásala directamente a `Client::new(...)`

Aquí tienes un ejemplo rápido con el SDK:

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

<div id="scraping-a-url">
  ### Hacer scraping de una URL
</div>

Para hacer scraping de una sola URL, usa el método `scrape`.

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

<div id="json-extraction">
  #### Extracción JSON
</div>

Extrae JSON estructurado con `scrape_with_schema`:

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

O bien configura la extracción JSON directamente con `ScrapeOptions`:

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

<div id="crawling-a-website">
  ### Rastreo de un sitio web
</div>

Para rastrear un sitio web y esperar a que finalice, usa `crawl`.

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

<div id="start-a-crawl">
  ### Iniciar un rastreo
</div>

Inicia un trabajo sin esperar utilizando `start_crawl`.

```rust theme={null}
use evocrawl::{Client, CrawlOptions};

let start = client.start_crawl(
    "https://evocrawl.com",
    CrawlOptions {
        limit: Some(100),
        ..Default::default()
    },
).await?;

println!("Job ID: {}", start.id);
```

<div id="checking-crawl-status">
  ### Consultar el estado del rastreo
</div>

Consulta el progreso del rastreo con `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);
```

<div id="cancelling-a-crawl">
  ### Cancelar un rastreo
</div>

Cancela un rastreo en curso con `cancel_crawl`.

```rust theme={null}
let result = client.cancel_crawl(&start.id).await?;
println!("{:?}", result);
```

<div id="checking-crawl-errors">
  ### Comprobar errores de rastreo
</div>

Recupera los errores de un trabajo de rastreo con `get_crawl_errors`.

```rust theme={null}
let errors = client.get_crawl_errors(&start.id).await?;
println!("{:?}", errors);
```

<div id="mapping-a-website">
  ### Mapeo de un sitio web
</div>

Descubre enlaces de un sitio con `map`.

```rust theme={null}
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(""));
}
```

Para obtener un resultado más simple, solo con URL, usa `map_urls`:

```rust theme={null}
let urls = client.map_urls("https://evocrawl.com", None).await?;
for url in &urls {
    println!("{}", url);
}
```

<div id="searching-the-web">
  ### Búsqueda en la web
</div>

Busca con opciones de configuración al utilizar `search`.

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

Para un método de conveniencia que devuelve directamente los documentos extraídos:

```rust theme={null}
let docs = client.search_and_scrape("evocrawl web scraping", 5).await?;
for doc in &docs {
    println!("{}", doc.markdown.as_deref().unwrap_or(""));
}
```

<div id="batch-scraping">
  ### Scraping por lotes
</div>

Realiza scraping de varias URL en paralelo con `batch_scrape`.

```rust theme={null}
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(""));
}
```

<div id="agent">
  ### Agente
</div>

Ejecuta un agente basado en IA con `agent`.

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

Con un esquema JSON para una salida estructurada:

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

<div id="scrape-bound-interactive-session">
  ## Sesión interactiva vinculada al scraping
</div>

Usa un ID de trabajo de scraping para ejecutar código adicional del navegador en el mismo contexto:

* `interact(...)` ejecuta código o prompts en la sesión del navegador vinculada al scraping.
* `stop_interaction(...)` detiene la sesión interactiva cuando hayas terminado.

```rust theme={null}
use evocrawl::{Client, ScrapeExecuteOptions, ScrapeExecuteLanguage};

let scrape_job_id = "550e8400-e29b-41d4-a716-446655440000";

// Ejecutar código en la sesión del browser
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);

// O usar un prompt en lenguaje natural
let run = client.interact(
    scrape_job_id,
    ScrapeExecuteOptions {
        prompt: Some("Click the pricing tab and summarize the plans".to_string()),
        ..Default::default()
    },
).await?;

// Detener la sesión cuando se termine
client.stop_interaction(scrape_job_id).await?;
```

<div id="configuration">
  ## Configuración
</div>

`Client::new(...)` y `Client::new_selfhosted(...)` crean el cliente.

| Opción                                     | Descripción                                                                          |
| ------------------------------------------ | ------------------------------------------------------------------------------------ |
| `Client::new(api_key)`                     | Crea un cliente para el servicio en la nube de Evocrawl (`https://api.evocrawl.com`) |
| `Client::new_selfhosted(api_url, api_key)` | Crea un cliente para una instancia autogestionada de Evocrawl                        |

```rust theme={null}
use evocrawl::Client;

// Servicio en la nube
let client = Client::new("fc-your-api-key")?;

// Autogestionado
let client = Client::new_selfhosted(
    "http://localhost:3002",
    Some("fc-your-api-key"),
)?;

// Autogestionado sin autenticación
let client = Client::new_selfhosted(
    "http://localhost:3002",
    None::<&str>,
)?;
```

<div id="environment-variable">
  ### Variable de entorno
</div>

Define la variable de entorno `EVOCRAWL_API_KEY` en lugar de pasar la clave directamente:

```bash theme={null}
export EVOCRAWL_API_KEY=fc-YOUR-API-KEY
```

```rust theme={null}
let api_key = std::env::var("EVOCRAWL_API_KEY")
    .expect("EVOCRAWL_API_KEY must be set");
let client = Client::new(api_key)?;
```

<div id="poll-intervals">
  ### Intervalos de sondeo
</div>

Los métodos síncronos (`crawl`, `batch_scrape`, `agent`) siguen consultando el estado hasta completarse. Puedes personalizar el intervalo de sondeo mediante la estructura `options`:

```rust theme={null}
use evocrawl::CrawlOptions;

let options = CrawlOptions {
    limit: Some(50),
    poll_interval: Some(3000), // Consultar cada 3 segundos (predeterminado: 2000ms)
    ..Default::default()
};
```

<div id="error-handling">
  ## Manejo de errores
</div>

El SDK usa el enum `EvocrawlError`, que implementa `Error`, `Debug` y `Display`. Todos los métodos devuelven `Result<T, EvocrawlError>`.

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

> ¿Eres un agente de IA que necesita una clave de API de Evocrawl? Consulta [evocrawl.dev/agent-onboarding/SKILL.md](https://www.evocrawl.com/agent-onboarding/SKILL.md) para obtener instrucciones de incorporación automatizadas.