Rust SDK

The official Rust SDK for the AllScreenshots API with async-first design using the tokio runtime.

Source code: GitHub | Crate: allscreenshots-sdk

Installation

Add to your Cargo.toml:

[dependencies]
allscreenshots-sdk = "0.1"
tokio = { version = "1", features = ["full"] }

Quick start

use allscreenshots_sdk::{AllscreenshotsClient, ScreenshotRequest};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = AllscreenshotsClient::from_env()?;

    let request = ScreenshotRequest::builder()
        .url("https://github.com")
        .device("Desktop HD")
        .build()?;

    let image_bytes = client.screenshot(&request).await?;
    std::fs::write("screenshot.png", &image_bytes)?;

    println!("Screenshot saved to screenshot.png");
    Ok(())
}

Configuration

From environment

// Reads API key from ALLSCREENSHOTS_API_KEY environment variable
let client = AllscreenshotsClient::from_env()?;

Builder pattern

use std::time::Duration;

let client = AllscreenshotsClient::builder()
    .api_key("your-api-key")
    .base_url("https://api.allscreenshots.com")
    .timeout(Duration::from_secs(60))
    .max_retries(3)
    .build()?;

Capture screenshots

Basic capture

let request = ScreenshotRequest::builder()
    .url("https://example.com")
    .build()?;

let image_bytes = client.screenshot(&request).await?;
std::fs::write("screenshot.png", &image_bytes)?;

With options

let request = ScreenshotRequest::builder()
    .url("https://example.com")
    .device("Desktop HD")
    .format("png")
    .full_page(true)
    .dark_mode(true)
    .block_ads(true)
    .block_cookie_banners(true)
    .delay(1000)
    .build()?;

let image_bytes = client.screenshot(&request).await?;

Device presets

// Desktop
let desktop = client.screenshot(
    &ScreenshotRequest::builder()
        .url("https://example.com")
        .device("Desktop HD")
        .build()?
).await?;

// Mobile
let mobile = client.screenshot(
    &ScreenshotRequest::builder()
        .url("https://example.com")
        .device("iPhone 15")
        .build()?
).await?;

// Tablet
let tablet = client.screenshot(
    &ScreenshotRequest::builder()
        .url("https://example.com")
        .device("iPad Pro 11")
        .build()?
).await?;

Async jobs

For long-running captures:

// Create async job
let job = client.screenshot_async(
    &ScreenshotRequest::builder()
        .url("https://example.com")
        .full_page(true)
        .build()?
).await?;

println!("Job ID: {}", job.job_id);

// Poll for completion
let status = client.get_job(&job.job_id).await?;

if status.status == "completed" {
    let image_bytes = client.get_job_result(&job.job_id).await?;
    std::fs::write("screenshot.png", &image_bytes)?;
}

Bulk capture

Process multiple URLs efficiently:

use allscreenshots_sdk::{BulkRequest, BulkUrl, BulkDefaults};

let bulk_job = client.bulk(&BulkRequest {
    urls: vec![
        BulkUrl { url: "https://example1.com".to_string(), ..Default::default() },
        BulkUrl { url: "https://example2.com".to_string(), ..Default::default() },
        BulkUrl { url: "https://example3.com".to_string(), ..Default::default() },
    ],
    defaults: Some(BulkDefaults {
        device: Some("Desktop HD".to_string()),
        format: Some("png".to_string()),
        ..Default::default()
    }),
}).await?;

// Check status
let status = client.get_bulk_job(&bulk_job.bulk_job_id).await?;

Composition

Combine multiple screenshots into a single image:

use allscreenshots_sdk::{ComposeRequest, Variant, OutputOptions};

let composed = client.compose(&ComposeRequest {
    url: "https://example.com".to_string(),
    variants: vec![
        Variant { device: "Desktop HD".to_string(), label: Some("Desktop".to_string()) },
        Variant { device: "iPhone 15".to_string(), label: Some("Mobile".to_string()) },
    ],
    output: Some(OutputOptions {
        layout: Some("horizontal".to_string()),
        spacing: Some(20),
        ..Default::default()
    }),
}).await?;

Schedules

Create recurring screenshot captures:

use allscreenshots_sdk::CreateScheduleRequest;

// Create a schedule
let schedule = client.schedules().create(&CreateScheduleRequest {
    name: "Daily Homepage".to_string(),
    url: "https://example.com".to_string(),
    schedule: "0 9 * * *".to_string(),
    timezone: Some("America/New_York".to_string()),
    ..Default::default()
}).await?;

// List schedules
let schedules = client.schedules().list().await?;

// Get captures
let captures = client.schedules().get_captures(&schedule.schedule_id).await?;

Usage tracking

Monitor your API usage:

let usage = client.usage().get().await?;
println!("Screenshots: {}/{}", usage.screenshot_count, usage.quota);

Error handling

The SDK provides typed errors for different scenarios:

use allscreenshots_sdk::Error;

match client.screenshot(&request).await {
    Ok(image_bytes) => {
        std::fs::write("screenshot.png", &image_bytes)?;
    }
    Err(Error::RateLimit { retry_after }) => {
        println!("Rate limited. Retry after {}s", retry_after);
    }
    Err(Error::Authentication(_)) => {
        println!("Invalid API key");
    }
    Err(Error::Validation(msg)) => {
        println!("Validation error: {}", msg);
    }
    Err(Error::Timeout) => {
        println!("Request timed out");
    }
    Err(e) => {
        println!("Error: {}", e);
    }
}

Concurrent requests

use futures::future::join_all;

let urls = vec![
    "https://example1.com",
    "https://example2.com",
    "https://example3.com",
];

let futures: Vec<_> = urls.iter().map(|url| {
    let client = client.clone();
    async move {
        let request = ScreenshotRequest::builder()
            .url(*url)
            .build()
            .unwrap();
        client.screenshot(&request).await
    }
}).collect();

let results = join_all(futures).await;

License

Apache License 2.0

Rust SDK

On this page