SDKs & Client Libraries

npm install @scrapio/api

import { ApiClient } from "@scrapio/api";

const client = new ApiClient({ apiKey: process.env.SCRAPIO_API_KEY! });

// Fetch a page
const page = await client.fetch.fetch({ url: "https://example.com", output: ["markdown"] });

// Google search
const results = await client.google.search({ search: "web scraping tools" });

// Amazon product
const product = await client.amazon.getProduct({ asin: "B08N5WRWNW" });

// Walmart search
const items = await client.walmart.search({ query: "headphones" });

// YouTube video
const video = await client.youtube.getVideo({ video_id: "dQw4w9WgXcQ" });

// Async job with polling helper
const job = await client.jobs.create({
  job_type: "fetch",
  payload: { url: "https://example.com", output: ["markdown"] },
});
const result = await client.jobs.waitForCompletion(job.job_id, {
  pollIntervalMs: 2000,
  timeoutMs: 120_000,
});

import {
  ApiClient,
  AuthError,
  RateLimitError,
  CreditsExhaustedError,
  ApiError,
} from "@scrapio/api";

try {
  await client.fetch.fetch({ url: "https://example.com" });
} catch (err) {
  if (err instanceof AuthError) {
    console.error("Invalid API key");
  } else if (err instanceof CreditsExhaustedError) {
    console.error("No credits remaining");
  } else if (err instanceof RateLimitError) {
    console.error("Rate limited — back off and retry");
  } else if (err instanceof ApiError) {
    console.error(`API error ${err.statusCode}: ${err.message}`);
  }
}

pip install scrapio-py

from scrapio import ApiClient

client = ApiClient(api_key=os.environ["SCRAPIO_API_KEY"])

from scrapio import AsyncApiClient

async with AsyncApiClient(api_key=os.environ["SCRAPIO_API_KEY"]) as client:
    ...

from scrapio import ApiClient, FetchRequest, GoogleSearchParams

client = ApiClient(api_key="sk-...")

# Fetch a page
page = client.fetch.fetch(FetchRequest(url="https://example.com", output=["markdown"]))

# Google search
results = client.google.search(GoogleSearchParams(search="web scraping tools"))

# Amazon product
product = client.amazon.get_product("B08N5WRWNW")

# Walmart search
items = client.walmart.search("headphones")

# YouTube video
video = client.youtube.get_video("dQw4w9WgXcQ")

# Async job with polling helper
from scrapio import CreateJobRequest

job = client.jobs.create(CreateJobRequest(
    job_type="fetch",
    payload={"url": "https://example.com", "output": ["markdown"]},
))
result = client.jobs.wait_for_completion(job.job_id, poll_interval=2.0, timeout=120.0)

import asyncio
from scrapio import AsyncApiClient, FetchRequest, CreateJobRequest

async def main():
    async with AsyncApiClient(api_key="sk-...") as client:
        page = await client.fetch.fetch(FetchRequest(url="https://example.com", output=["markdown"]))
        job = await client.jobs.create(CreateJobRequest(
            job_type="fetch",
            payload={"url": "https://example.com", "output": ["markdown"]},
        ))
        result = await client.jobs.wait_for_completion(job.job_id, poll_interval=2.0, timeout=120.0)

asyncio.run(main())

from scrapio import (
    ApiClient, FetchRequest,
    AuthError, RateLimitError, CreditsExhaustedError, ApiError,
)

try:
    client.fetch.fetch(FetchRequest(url="https://example.com"))
except AuthError:
    print("Invalid API key")
except CreditsExhaustedError:
    print("No credits remaining")
except RateLimitError:
    print("Rate limited — back off and retry")
except ApiError as e:
    print(f"API error {e.status_code}: {e}")

go get github.com/xsronhou/scrapio-go

import scrapio "github.com/xsronhou/scrapio-go"

client := scrapio.NewClient("YOUR_API_KEY")
// or from env:
client := scrapio.NewClient(os.Getenv("SCRAPIO_API_KEY"))

// Fetch a page
result, err := client.Fetch.Fetch(ctx, &scrapio.FetchRequest{
    URL:    "https://example.com",
    Output: []string{"markdown"},
})
fmt.Println(*result.Outputs.Markdown)

// Google search
results, err := client.Google.Search(ctx, &scrapio.GoogleSearchRequest{
    Search: "web scraping tools",
})

// Async job
job, err := client.Jobs.Create(ctx, &scrapio.CreateJobRequest{
    JobType: "fetch",
    Payload: map[string]any{"url": "https://example.com", "output": []string{"markdown"}},
})
result, err := client.Jobs.WaitForCompletion(ctx, job.JobID, nil)

gem install scrapio

require "scrapio"

client = Scrapio::Client.new(api_key: ENV["SCRAPIO_API_KEY"])

# Fetch a page
result = client.fetch.fetch(url: "https://example.com", output: ["markdown"])
puts result.outputs["markdown"]

# Google search
results = client.google.search(search: "web scraping tools")

# Amazon product
product = client.amazon.get_product(asin: "B08N5WRWNW")

# Async job
job = client.jobs.create(job_type: "fetch", payload: { url: "https://example.com", output: ["markdown"] })
result = client.jobs.wait_for_completion(job.job_id)

composer require scrapio/scrapio

use Scrapio\ScrapioClient;

$client = new ScrapioClient(apiKey: $_ENV["SCRAPIO_API_KEY"]);

// Fetch a page
$result = $client->fetch->fetch([
    "url"    => "https://example.com",
    "output" => ["markdown"],
]);
echo $result->outputs["markdown"];

// Google search
$results = $client->google->search(["search" => "web scraping tools"]);

// Amazon product
$product = $client->amazon->getProduct(["asin" => "B08N5WRWNW"]);

// Async job
$job = $client->jobs->create([
    "job_type" => "fetch",
    "payload"  => ["url" => "https://example.com", "output" => ["markdown"]],
]);
$result = $client->jobs->waitForCompletion($job->jobId);

<dependency>
    <groupId>dev.scrapio</groupId>
    <artifactId>scrapio-java</artifactId>
    <version>1.0.0</version>
</dependency>

implementation 'dev.scrapio:scrapio-java:1.0.0'

import dev.scrapio.ScrapioClient;

ScrapioClient client = ScrapioClient.builder()
    .apiKey(System.getenv("SCRAPIO_API_KEY"))
    .build();

// Fetch a page
var result = client.fetch().fetch(
    FetchRequest.builder()
        .url("https://example.com")
        .output(List.of("markdown"))
        .build()
);
System.out.println(result.getOutputs().getMarkdown());

// Google search
var results = client.google().search(
    GoogleSearchRequest.builder().search("web scraping tools").build()
);

// Async job
var job = client.jobs().create(
    CreateJobRequest.builder()
        .jobType("fetch")
        .payload(Map.of("url", "https://example.com", "output", List.of("markdown")))
        .build()
);
var completed = client.jobs().waitForCompletion(job.getJobId());