Rust Client

[dependencies]
evomi-client = "0.1.2"
tokio = { version = "1", features = ["full"] }

use evomi_client::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize with API key (or set EVOMI_API_KEY env var)
    let client = Client::new("your-api-key", None, None)?;
    
    // Scrape a URL
    let result = client.scrape("https://example.com", None).await?;
    println!("{:?}", result);
    
    Ok(())
}

export EVOMI_API_KEY="your-api-key"

let client = Client::new("your-api-key", None, None)?;

let client = Client::new("your-api-key", Some("https://custom.evomi.com".to_string()), None)?;

use evomi_client::{Client, ScrapeOptions};

let result = client.scrape("https://example.com", Some(ScrapeOptions {
    mode: Some("auto".to_string()),
    content: Some("markdown".to_string()),
    device: Some("windows".to_string()),
    proxy_type: Some("residential".to_string()),
    proxy_country: Some("US".to_string()),
    proxy_session_id: Some("abc123".to_string()),
    wait_until: Some("domcontentloaded".to_string()),
    ai_enhance: Some(true),
    ai_prompt: Some("Extract product data".to_string()),
    ai_source: Some("markdown".to_string()),
    js_instructions: Some(vec![serde_json::json!({"click": ".load-more"})]),
    execute_js: Some("window.scrollTo(0, document.body.scrollHeight)".to_string()),
    wait_seconds: Some(2),
    screenshot: Some(false),
    pdf: Some(false),
    excluded_tags: Some(vec!["nav".to_string(), "footer".to_string()]),
    excluded_selectors: Some(vec![".ads".to_string()]),
    block_resources: Some(vec!["image".to_string(), "stylesheet".to_string()]),
    capture_headers: Some(true),
    async_mode: Some(false),
    config_id: Some("cfg_abc123".to_string()),
    scheme_id: Some("sch_abc123".to_string()),
    extract_scheme: Some(vec![serde_json::json!({"label": "title", "type": "content", "selector": "h1"})]),
    storage_id: Some("stor_abc123".to_string()),
    use_default_storage: Some(false),
    
    webhook: None,
    ..Default::default()
})).await?;

use evomi_client::CrawlOptions;

let result = client.crawl("example.com", Some(CrawlOptions {
    max_urls: Some(100),
    depth: Some(2),
    url_pattern: Some("/blog/.*".to_string()),
    scraper_config: Some(serde_json::json!({"mode": "browser", "output": "markdown"})),
    async_mode: Some(false),
    webhook: None,
})).await?;

use evomi_client::MapOptions;

let result = client.map_website("example.com", Some(MapOptions {
    sources: Some(vec!["sitemap".to_string(), "commoncrawl".to_string()]),
    max_urls: Some(500),
    url_pattern: Some("/products/.*".to_string()),
    check_if_live: Some(false),
    depth: Some(1),
    async_mode: Some(false),
    webhook: None,
})).await?;

use evomi_client::SearchOptions;

// Single query
let result = client.search_domains("e-commerce platforms", Some(SearchOptions {
    max_urls: Some(20),
    region: Some("us-en".to_string()),
    webhook: None,
})).await?;

// Multiple queries (up to 10)
let result = client.search_domains(
    vec!["web scraping tools".to_string(), "data extraction".to_string()],
    Some(SearchOptions { max_urls: Some(20), ..Default::default() })
).await?;

let result = client.agent_request("Scrape example.com and extract all product prices").await?;

let result = client.get_task_status("abc123", "scrape").await?;
// task_type: "scrape" | "crawl" | "map" | "config_generate" | "schema"

use evomi_client::ListOptions;

let configs = client.list_configs(Some(ListOptions {
    page: Some(1),
    per_page: Some(20),
    sort_by: Some("created_at".to_string()),
    sort_order: Some("desc".to_string()),
})).await?;

let config = client.create_config("Product Scraper", serde_json::json!({
    "mode": "browser",
    "output": "markdown"
})).await?;

let config = client.get_config("cfg_abc123").await?;

let config = client.update_config("cfg_abc123", Some("New Name"), Some(serde_json::json!({
    "mode": "request"
}))).await?;

let result = client.delete_config("cfg_abc123").await?;

let config = client.generate_config(
    "Amazon Scraper",
    "Scrape product title and price from Amazon product pages"
).await?;

let schemas = client.list_schemas(Some(ListOptions {
    page: Some(1),
    per_page: Some(20),
    sort_by: Some("created_at".to_string()),
    sort_order: Some("desc".to_string()),
})).await?;

use evomi_client::CreateSchemaOptions;

let schema = client.create_schema("Product Schema", serde_json::json!({
    "url": "https://example.com/product",
    "extract_scheme": [
        {"label": "title", "type": "content", "selector": "h1"},
        {"label": "price", "type": "content", "selector": ".price"}
    ]
}), Some(CreateSchemaOptions {
    test: Some(true),
    fix: Some(false),
    extract_prompt: None,
})).await?;

let schema = client.get_schema("sch_abc123").await?;

let schema = client.update_schema("sch_abc123", "Updated Schema", serde_json::json!({
    "url": "...",
    "extract_scheme": [...]
}), Some(CreateSchemaOptions {
    test: Some(true),
    ..Default::default()
})).await?;

let result = client.delete_schema("sch_abc123").await?;

let status = client.get_schema_status("sch_abc123").await?;

let schedules = client.list_schedules(Some(ListOptions {
    page: Some(1),
    per_page: Some(20),
    ..Default::default()
}), Some(false)).await?;

use evomi_client::CreateScheduleOptions;

let schedule = client.create_schedule(
    "Daily Price Check",
    "cfg_abc123",
    1440,  // Daily (in minutes)
    Some(CreateScheduleOptions {
        start_time: Some("09:00".to_string()),
        stop_on_error: Some(true),
        webhook: None,
    })
).await?;

let schedule = client.get_schedule("sched_abc123").await?;

let schedule = client.update_schedule(
    "sched_abc123",
    Some("New Name"),
    None,
    Some(720),
    None
).await?;

let result = client.delete_schedule("sched_abc123").await?;

let result = client.toggle_schedule("sched_abc123").await?;

let runs = client.list_schedule_runs("sched_abc123", Some(1), Some(20)).await?;

let configs = client.list_storage_configs().await?;

use evomi_client::CreateStorageOptions;

// S3-compatible storage
let storage = client.create_storage_config(
    "My S3",
    "s3_compatible",
    serde_json::json!({
        "bucket": "my-bucket",
        "region": "us-east-1",
        "access_key": "...",
        "secret_key": "..."
    }),
    Some(CreateStorageOptions {
        set_as_default: Some(true),
    })
).await?;

// Google Cloud Storage
let storage = client.create_storage_config(
    "My GCS",
    "gcs",
    serde_json::json!({
        "bucket": "my-bucket",
        "credentials_json": "..."
    }),
    None
).await?;

// Azure Blob Storage
let storage = client.create_storage_config(
    "My Azure",
    "azure_blob",
    serde_json::json!({
        "container": "my-container",
        "connection_string": "..."
    }),
    None
).await?;

let storage = client.update_storage_config(
    "stor_abc123",
    Some("Renamed Storage"),
    None,
    Some(true)
).await?;

let result = client.delete_storage_config("stor_abc123").await?;

let data = client.get_public_api().await?;
// Returns proxy credentials and product information

let data = client.get_proxy_data().await?;
// Returns: {"products": {"rp": {...}, "sdc": {...}, "mp": {...}}, ...}

let options = client.get_targeting_options().await?;

let data = client.get_scraper_data().await?;

let data = client.get_browser_data().await?;

let result = client.rotate_session("abc12345", "rp").await?;
// product: "rpc", "rp", "sdc", "mp"

use evomi_client::GenerateProxiesOptions;

let proxies = client.generate_proxies("rp", Some(GenerateProxiesOptions {
    countries: Some("US,GB,DE".to_string()),
    city: Some("New York".to_string()),
    session: Some("sticky".to_string()),
    amount: Some(10),
    protocol: Some("http".to_string()),
    lifetime: Some(30),
    adblock: Some(true),
    ..Default::default()
})).await?;
// Returns plain text, one proxy per line

let info = client.get_account_info().await?;
println!("{:?}", info.get("credits_remaining"));

use evomi_client::WebhookConfig;

// Discord webhook
let webhook = WebhookConfig::new("https://discord.com/api/webhooks/...")
    .webhook_type("discord")
    .events(vec!["completed".to_string(), "failed".to_string()]);

// Custom webhook with HMAC signature
let webhook = WebhookConfig::new("https://your-server.com/webhook")
    .webhook_type("custom")
    .events(vec!["completed".to_string()])
    .secret("your-secret-key");

let webhook = WebhookConfig::new("https://discord.com/api/webhooks/...")
    .webhook_type("discord")
    .events(vec!["completed".to_string(), "failed".to_string()]);

let result = client.scrape("https://example.com", Some(ScrapeOptions {
    mode: Some("browser".to_string()),
    webhook: Some(webhook),
    ..Default::default()
})).await?;

let webhook = WebhookConfig::new("https://hooks.slack.com/services/...")
    .webhook_type("slack")
    .events(vec!["completed".to_string()]);

let schedule = client.create_schedule(
    "Daily Monitor",
    "cfg_abc123",
    1440,
    Some(CreateScheduleOptions {
        webhook: Some(webhook),
        ..Default::default()
    })
).await?;

use evomi_client::types::{ProxyType, ProxyProtocol, ProxyBuildOptions};

// Build a proxy string for US residential proxy
let proxy_string = client.build_proxy_string(
    ProxyType::Residential,
    Some(ProxyBuildOptions::new()
        .country("US")
        .session("abc12345")
        .protocol(ProxyProtocol::Http))
).await?;
println!("{}", proxy_string);
// Output: http://user:[email protected]:1000

use evomi_client::proxy::ProxyConfig;
use evomi_client::types::{ProxyType, ProxyProtocol, ResidentialMode};

let config = ProxyConfig::new()
    .proxy_type(ProxyType::Residential)
    .protocol(ProxyProtocol::Http)
    .country("US")
    .city("New York")
    .credentials("username", "password");

let proxy_string = config.build_proxy_string();

use evomi_client::Error;

match client.scrape("https://example.com", None).await {
    Ok(result) => println!("{:?}", result),
    Err(Error::MissingApiKey) => eprintln!("API key not set"),
    Err(Error::HttpError(e)) => eprintln!("HTTP error: {}", e),
    Err(Error::JsonError(e)) => eprintln!("JSON error: {}", e),
    Err(Error::ApiError(msg)) => eprintln!("API error: {}", msg),
    Err(e) => eprintln!("Other error: {}", e),
}

println!("{:?}", result.get("_credits_used"));
println!("{:?}", result.get("_credits_remaining"));