Swift SDK

The official Swift SDK for the AllScreenshots API with native async/await support.

Source code: GitHub | Package: allscreenshots-sdk-swift

Requirements

Swift 5.9 or higher
iOS 15.0+ / macOS 12.0+ / tvOS 15.0+ / watchOS 8.0+

Installation

Add to your Package.swift:

dependencies: [
    .package(url: "https://github.com/allscreenshots/allscreenshots-sdk-swift.git", from: "1.0.0")
]

Then add the dependency to your target:

targets: [
    .target(
        name: "YourTarget",
        dependencies: ["AllScreenshotsSDK"]
    )
]

Quick start

import AllScreenshotsSDK

let client = try AllScreenshotsClient()

let request = ScreenshotRequest(
    url: "https://example.com",
    device: "Desktop HD"
)

let imageData = try await client.takeScreenshot(request)
try imageData.write(to: URL(fileURLWithPath: "screenshot.png"))

Configuration

From environment

// Reads API key from ALLSCREENSHOTS_API_KEY environment variable
let client = try AllScreenshotsClient()

Direct configuration

let client = try AllScreenshotsClient(
    apiKey: "your-api-key",
    baseUrl: "https://api.allscreenshots.com",
    timeout: 60
)

Capture screenshots

Basic capture

let request = ScreenshotRequest(url: "https://example.com")
let imageData = try await client.takeScreenshot(request)

With options

let request = ScreenshotRequest(
    url: "https://example.com",
    device: "Desktop HD",
    format: .png,
    fullPage: true,
    darkMode: true,
    blockAds: true,
    blockCookieBanners: true,
    delay: 1000
)

let imageData = try await client.takeScreenshot(request)

Device presets

// Desktop
let desktop = try await client.takeScreenshot(
    ScreenshotRequest(url: "https://example.com", device: "Desktop HD")
)

// Mobile
let mobile = try await client.takeScreenshot(
    ScreenshotRequest(url: "https://example.com", device: "iPhone 15")
)

// Tablet
let tablet = try await client.takeScreenshot(
    ScreenshotRequest(url: "https://example.com", device: "iPad Pro 11")
)

Async jobs

For long-running captures:

// Create async job
let job = try await client.takeScreenshotAsync(
    ScreenshotRequest(url: "https://example.com", fullPage: true)
)

print("Job ID: \(job.id)")

// Poll for completion
while true {
    let status = try await client.getJob(job.id)
    if status.status == .completed {
        let imageData = try await client.getJobResult(job.id)
        try imageData.write(to: URL(fileURLWithPath: "screenshot.png"))
        break
    }
    try await Task.sleep(nanoseconds: 1_000_000_000) // 1 second
}

Bulk capture

Process multiple URLs efficiently:

let bulkJob = try await client.createBulkJob(
    urls: [
        BulkUrl(url: "https://example1.com"),
        BulkUrl(url: "https://example2.com"),
        BulkUrl(url: "https://example3.com")
    ],
    defaults: BulkDefaults(
        device: "Desktop HD",
        format: .png
    )
)

// Check status
let status = try await client.getBulkJob(bulkJob.bulkJobId)

Composition

Combine multiple screenshots into a single image:

let composed = try await client.compose(
    url: "https://example.com",
    variants: [
        Variant(device: "Desktop HD", label: "Desktop"),
        Variant(device: "iPhone 15", label: "Mobile")
    ],
    output: OutputOptions(layout: .horizontal, spacing: 20)
)

Schedules

Create recurring screenshot captures:

// Create a schedule
let schedule = try await client.createSchedule(
    name: "Daily Homepage",
    url: "https://example.com",
    schedule: "0 9 * * *",
    timezone: "America/New_York"
)

// List schedules
let schedules = try await client.listSchedules()

// Get captures
let captures = try await client.getScheduleCaptures(schedule.scheduleId)

Usage tracking

Monitor your API usage:

let usage = try await client.getUsage()
print("Screenshots: \(usage.screenshotCount)/\(usage.quota)")

SwiftUI integration

import SwiftUI
import AllScreenshotsSDK

struct ScreenshotView: View {
    @State private var image: UIImage?
    @State private var isLoading = false

    let client = try! AllScreenshotsClient()

    var body: some View {
        VStack {
            if let image = image {
                Image(uiImage: image)
                    .resizable()
                    .aspectRatio(contentMode: .fit)
            } else if isLoading {
                ProgressView()
            }

            Button("Take Screenshot") {
                Task {
                    await captureScreenshot()
                }
            }
        }
    }

    func captureScreenshot() async {
        isLoading = true
        defer { isLoading = false }

        do {
            let request = ScreenshotRequest(
                url: "https://example.com",
                device: "iPhone 15"
            )
            let data = try await client.takeScreenshot(request)
            image = UIImage(data: data)
        } catch {
            print("Error: \(error)")
        }
    }
}

Error handling

do {
    let imageData = try await client.takeScreenshot(request)
} catch AllScreenshotsError.rateLimited(let retryAfter) {
    print("Rate limited. Retry after \(retryAfter)s")
} catch AllScreenshotsError.authentication {
    print("Invalid API key")
} catch AllScreenshotsError.validation(let message) {
    print("Validation error: \(message)")
} catch AllScreenshotsError.timeout {
    print("Request timed out")
} catch {
    print("Error: \(error)")
}

Concurrent requests

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

let screenshots = try await withThrowingTaskGroup(of: (String, Data).self) { group in
    for url in urls {
        group.addTask {
            let request = ScreenshotRequest(url: url)
            let data = try await client.takeScreenshot(request)
            return (url, data)
        }
    }

    var results: [(String, Data)] = []
    for try await result in group {
        results.append(result)
    }
    return results
}

License

Apache License 2.0

Swift SDK

On this page