API Documentation | Raspbytes

Product guides, request examples, endpoint references, and troubleshooting all live here. Product links in the dashboard open the relevant section in a new tab, so you can keep your current workflow open.

Authentication

Create an API key

API keys authenticate automated requests across Raspbytes products. Create a dedicated key for each application, grant only the product permissions it needs, and keep it outside your source code.

Open Credentials

Create the key

Give the key a recognisable name and grant only the product read or write permissions the application needs.

Save it securely

Copy the key when it is shown and store it in your deployment secret manager.

Set the API key for local developmentShell

export RASPBYTES_API_KEY='rb_live_your_key_here'

Keep the key private

Do not commit API keys to Git, include them in client-side code, or send them in support messages.

Open Credentials

API key permissions by product
Product	Read permission	Write permission
Proxies	proxies:read	proxies:write
Browser API	browser:read	browser:write
Web Unblocker	unblocker:read	unblocker:write
SERP API	serp:read	serp:write
Dataset API	dataset:read	dataset:write

Quickstart

Create your first connection

The dashboard is the quickest route for a first connection. Use the customer API when connection creation is part of an automated workflow.

From the dashboard

Open Proxies and select a proxy product.

Choose Get Proxy, then select the available country, protocol, and session type.

For a sticky session, choose a duration within the range shown on the form.

Create the proxy and copy the connection URL.

Test it before adding it to a production workload.

From the API

Start with a product example below. Each example creates a proxy, reads the returned connection URL, and sends a test request through it.

Authenticate. Send your API key in the X-API-Key header.

Create. POST the product and connection settings to /proxies/get_proxy/.

Connect. Use proxy_url exactly as returned; it already contains the credentials and endpoint.

View a complete API example

Proxy products

Choose the network that fits the workload

Residential and Datacenter Proxies use the same customer API, while the proxy_type value selects the product for the connection.

Location-sensitive access

Residential Proxies

Residential network addresses for workflows where geographic relevance and network identity matter.

Rotating and sticky sessions

Configurable sticky-session duration

Targeting from live account options

Bandwidth-based PAYG and subscriptions

Product overview

Fast shared capacity

Datacenter Proxies

Shared datacenter addresses for high-throughput, concurrent, and cost-efficient application and data workloads.

Shared IP pool

Rotating and sticky sessions

Configurable sticky-session duration

Bandwidth-based PAYG and subscriptions

Product overview

Residential Proxies

Create and connect to a Residential proxy

Use Residential Proxies when the workflow benefits from consumer-network routing and location context.

Create

Request a residential proxies connection.

Read

Take proxy_url from the successful JSON response.

Connect

Pass that URL to your proxy-aware HTTP client.

cURLShell · curl + jq

response=$(curl --fail-with-body --silent --show-error \
  -X POST "https://api.raspbytes.com/api/v1/proxy/proxies/get_proxy/" \
  -H "X-API-Key: $RASPBYTES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "proxy_type": "residential",
    "session_type": "rotating",
    "country": "US",
    "protocol": "http",
    "protocol_selection": "http_https"
  }')

proxy_url=$(printf '%s' "$response" | jq -r '.proxy_url')
curl --fail --show-error --proxy "$proxy_url" \
  "https://ipinfo.io/json"

Handle the response

A successful request returns proxy_url. Use it exactly as returned because it contains the generated proxy username, password, hostname, and port.

Choose the generated protocols

Use all, http_https, or socks5 for protocol_selection. Multiple URLs are returned in connection_strings_by_protocol when applicable.

View Residential Proxies

Datacenter Proxies

Create and connect to a Datacenter proxy

Use Datacenter Proxies for fast, cost-efficient workloads through the shared datacenter pool.

Create

Request a datacenter proxies connection.

Read

Take proxy_url from the successful JSON response.

Connect

Pass that URL to your proxy-aware HTTP client.

cURLShell · curl + jq

response=$(curl --fail-with-body --silent --show-error \
  -X POST "https://api.raspbytes.com/api/v1/proxy/proxies/get_proxy/" \
  -H "X-API-Key: $RASPBYTES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "proxy_type": "datacenter",
    "session_type": "rotating",
    "country": "US",
    "protocol": "http",
    "protocol_selection": "http_https"
  }')

proxy_url=$(printf '%s' "$response" | jq -r '.proxy_url')
curl --fail --show-error --proxy "$proxy_url" \
  "https://ipinfo.io/json"

Handle the response

A successful request returns proxy_url. Use it exactly as returned because it contains the generated proxy username, password, hostname, and port.

Choose the generated protocols

Use all, http_https, or socks5 for protocol_selection. Multiple URLs are returned in connection_strings_by_protocol when applicable.

View Datacenter Proxies

API reference

Proxy API endpoints and fields

The Proxy API is public documentation and does not require a Raspbytes login to read. Authentication is required only when sending a customer API request.

Proxy API base URLHTTPS

https://api.raspbytes.com/api/v1/proxy

Authentication

Send your customer API key in the X-API-Key header. Use proxies:read to read options and create connections, and add proxies:write when releasing sticky sessions.

GET/proxies/options/

Returns the proxy products, countries, targeting values, protocols, session types, and sticky-session duration limits currently available.

POST/proxies/get_proxy/

Creates a rotating, sticky, or static proxy connection using supported options.

PUT/proxies/release_sticky_session/

Releases a sticky session when the related workflow has finished.

Create-connection request fields

proxy_type

Proxy network type, such as residential or datacenter.

session_type

Use rotating, sticky, or static when supported by the selected proxy product.

country

Optional two-letter country code returned by the options endpoint.

protocol_selection

Protocols to generate: all, http_https, or socks5.

protocol

Optional primary protocol within the selected protocol group.

session_id

Optional for sticky sessions. Use 1-25 letters, numbers, or underscores; Raspbytes generates an identifier when omitted.

lifetime_minutes

Sticky sessions only. Send a whole number within sticky_session.lifetime_minutes from the options response, or omit it to use the 5-minute default.

Targeting

Add targeting only when the workflow needs it

Country is the common starting point. More specific targeting depends on the selected proxy product and location. State and city cannot be combined in one request.

Proxy targeting fields and usage
Field	How to use it
country	Two-letter country code, for example US or GB.
state	A supported state or region for the selected country.
city	A supported city for the selected country; do not combine with state.
asn	A supported network number for the selected country.

Sessions

Set sticky duration from the available limits

Rotating sessions can change address between requests. Sticky sessions keep continuity for a selected number of minutes. Read the options for the proxy product first because the allowed minimum, maximum, and default are part of the live API contract.

Read sticky-session limitsCode

curl --fail-with-body --silent --show-error \\
  "https://api.raspbytes.com/api/v1/proxy/proxies/options/?proxy_type=residential" \\
  -H "X-API-Key: $RASPBYTES_API_KEY"

Sticky-session options responseJSON · example

{
  "session_types": [
    { "value": "rotating", "label": "Rotating" },
    { "value": "sticky", "label": "Sticky" }
  ],
  "sticky_session": {
    "lifetime_minutes": {
      "min": 3,
      "max": 1440,
      "default": 5
    }
  }
}

Create a sticky sessionJSON · request body

{
  "proxy_type": "datacenter",
  "session_type": "sticky",
  "session_id": "catalog_check_1",
  "lifetime_minutes": 30,
  "country": "US",
  "protocol": "http",
  "protocol_selection": "http_https"
}

Duration rules

Use a whole number of minutes.
Stay within the returned minimum and maximum.
Omit lifetime_minutes to use the 5-minute default.
Send lifetime_minutes only when session_type is sticky.

Reuse the returned connection URL for related requests during the selected duration. Release the session through the dashboard or API when the workflow finishes early.

Connect

Use the returned URL without modifying it

The connection URL works with proxy-aware tools. Do not construct usernames, infer ports, or append targeting instructions yourself.

Test a connectionCode

export RASPBYTES_PROXY_URL='<proxy_url returned by Raspbytes>'
curl --proxy "$RASPBYTES_PROXY_URL" https://ipinfo.io/json

PythonCode

import os
import requests

proxy_url = os.environ["RASPBYTES_PROXY_URL"]
proxies = {
    "http": proxy_url,
    "https": proxy_url,
}

response = requests.get(
    "https://ipinfo.io/json",
    proxies=proxies,
    timeout=30,
)
response.raise_for_status()
print(response.json())

Browser API

Launch a browser for automated workflows

Create an ephemeral Chromium or Firefox session, wait until it is ready, and pass its WebSocket connection URL to a compatible automation client.

Configure

Read the live browser, environment, proxy, and account limits.

Create

Create a session and poll its detail endpoint until it is ready.

Connect

Use the returned CDP or WebDriver BiDi URL with your automation client.

Base URLhttps://api.raspbytes.com/api/v1/browser

AuthenticationBearer or X-API-Key

ProtocolsChromium CDP · Firefox BiDi

Browser API permissions

Grant browser:read to read options, sessions, entitlements, and usage. Add browser:write to create and terminate sessions. Send the key as Authorization: Bearer <key> or X-API-Key: <key>.

Browser API · Create

Create and wait for a browser session

Read the options and entitlement endpoints first, then create the session using only values enabled for the account.

Create a Chromium sessionShell · curl

curl --fail-with-body --silent --show-error \
  -X POST "https://api.raspbytes.com/api/v1/browser/sessions/" \
  -H "Authorization: Bearer $RASPBYTES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "browser": "chromium",
    "browser_version": "stable",
    "environment_profile": "desktop-balanced",
    "proxy": {
      "type": "datacenter",
      "country": "GB",
      "sticky": false
    },
    "session_timeout_seconds": 900
  }'

Ready session responseJSON

{
  "id": "brs_example",
  "status": "ready",
  "browser": "chromium",
  "protocol": "cdp",
  "connection": {
    "protocol": "cdp",
    "url": "wss://browser.raspbytes.com/v1/connect/bc_example",
    "expires_at": "2026-09-12T12:15:00Z"
  },
  "proxy": {
    "type": "datacenter",
    "country": "GB",
    "sticky": false
  }
}

Create-session fields

browser

chromium for a CDP session or firefox for a WebDriver BiDi session.

browser_version

Use stable or another selector returned by /session-options/.

environment_profile

A managed desktop profile returned by /session-options/. Raw fingerprint overrides are not accepted.

proxy.type

A Browser API proxy product returned by /proxy-options/.

proxy.country

Optional country from /proxy-options/. When omitted, Raspbytes selects an available country and aligns the managed browser identity.

proxy.sticky

Whether to keep the selected proxy route for the browser session.

session_timeout_seconds

Requested session lifetime. The accepted value is constrained by the account entitlement.

Read live options

Use GET /proxy-options/ for enabled routing products and countries, and GET /session-options/ for browser versions and managed environment profiles.

Automatic country selection

Omit proxy.country to let Raspbytes select an available country for the chosen Browser API proxy product. The resolved country is returned on the session.

Poll until the session is connectableJavaScript

const headers = {
  Authorization: "Bearer " + process.env.RASPBYTES_API_KEY,
};

let session;
do {
  const response = await fetch(
    "https://api.raspbytes.com/api/v1/browser/sessions/brs_example/",
    { headers },
  );
  if (!response.ok) throw new Error("Session lookup failed: " + response.status);
  session = await response.json();
  if (["failed", "expired", "terminated", "node_lost"].includes(session.status)) {
    throw new Error("Browser session ended with status " + session.status);
  }
  if (!session.connection?.url) await new Promise(resolve => setTimeout(resolve, 1000));
} while (!session.connection?.url);

console.log(session.protocol, session.connection.url);

Browser API · Connect

Use the client that matches the returned protocol

Chromium returns a CDP connection and Firefox returns a WebDriver BiDi connection. Treat the WebSocket URL as an opaque bearer credential.

Chromium · PlaywrightJavaScript

import { chromium } from "playwright";

const browser = await chromium.connectOverCDP(process.env.BROWSER_URL);
try {
  const context = browser.contexts()[0];
  if (!context) throw new Error("Browser context unavailable");

  const page = await context.newPage();
  await page.goto("https://example.com", {
    waitUntil: "domcontentloaded",
    timeout: 30_000,
  });
  console.log(await page.title());
} finally {
  await browser.close();
}

Chromium

When protocol is cdp, connect with Playwright's chromium.connectOverCDP() or another CDP-compatible client.

Firefox

When protocol is bidi, use a WebDriver BiDi client such as Puppeteer with protocol: "webDriverBiDi".

Do not log or persist a connection URL. If its credential expires while the session remains available, read the session detail again to obtain the current connection URL.

Browser API · Lifecycle

Reconnect, terminate, and inspect usage

A client disconnect does not end the managed session. Reconnect while it remains available, or terminate it explicitly when the workflow finishes.

GET/sessions/{session_id}/

Refresh status and connection details.

DELETE/sessions/{session_id}/

Stop the session on demand.

GET/usage/

Read aggregate runtime and traffic.

GET/usage/history/?page=1&page_size=25

Read paginated usage events.

Lifecycle behaviour

ready means the browser can accept a client connection.

connected means a client currently controls the browser.

disconnected (shown as Available in the dashboard) means the browser can be reconnected.

terminated, expired, failed, and node_lost sessions cannot be reconnected.

Concurrency and traffic

Read GET /entitlement/ before creating sessions. It returns the current session limit, maximum timeout, traffic allowance, usage, and remaining traffic.

Browser API · Reference

Endpoints, response fields, and errors

All paths below are relative to the Browser API base URL. Customer responses contain product-facing session information and omit infrastructure details.

GET/plans/

List the Browser API plans currently available.

GET/proxy-options/

List proxy products and countries enabled for browser sessions.

GET/session-options/

List browser versions, managed environments, and regional identities.

GET/entitlement/

Read the current traffic allowance, remaining traffic, concurrency, and timeout limits.

GET/sessions/

List browser sessions. Add page and page_size for a paginated response.

POST/sessions/

Create a Chromium CDP or Firefox WebDriver BiDi session.

GET/sessions/{session_id}/

Read the latest session state and connection endpoint.

DELETE/sessions/{session_id}/

Terminate a browser session immediately.

GET/usage/

Read aggregate Browser API usage.

GET/usage/history/

Read paginated usage events, optionally filtered by session.

Session response fields

id

Stable Browser API session identifier used by detail and termination requests.

status

Current lifecycle state, such as starting, ready, connected, disconnected, terminated, expired, failed, or node_lost.

browser

The selected browser family: chromium or firefox.

protocol

cdp for Chromium or bidi for Firefox.

connection.url

Bearer WebSocket credential for the selected automation protocol. Keep it private.

connection.expires_at

Time at which the current connection credential or session expires.

proxy

Resolved Browser API proxy type, country, region, and sticky setting.

environment

The resolved managed viewport, locale, timezone, and identity properties.

usage

Recorded session duration and browser traffic counters.

400A browser, version, environment, proxy, country, or timeout value is invalid.

401The API key is missing or invalid.

402Browser traffic is exhausted or a Browser API plan is required.

403The API key does not have the required browser:read or browser:write permission.

404The requested browser session does not exist or belongs to another account.

429The account concurrency limit has been reached.

503The browser could not be started or is temporarily unavailable. Retry when the response marks the error as retryable.

Web Unblocker

Retrieve a page without managing proxy operations

Send a public URL and receive the page content. Raspbytes handles routing, retries, blocking, and JavaScript rendering when the destination requires it.

Submit

Send the target URL and retrieval settings.

Retrieve

Raspbytes selects and executes the appropriate access strategy.

Use

Read the returned page content and response metadata.

Base URLhttps://api.raspbytes.com/api/v1/unblock

AuthenticationX-API-Key

Default modeAutomatic

Permissions

Grant unblocker:write to retrieve or queue pages and unblocker:read to inspect request history.

Web Unblocker · Requests

Choose synchronous or asynchronous delivery

Use synchronous retrieval when the caller can wait for the completed page. Queue the request when the application should collect the result later.

Retrieve nowShell · curl

curl --fail-with-body --silent --show-error \
  -X POST "https://api.raspbytes.com/api/v1/unblock/" \
  -H "X-API-Key: $RASPBYTES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/products",
    "method": "GET",
    "strategy": "adaptive"
  }'

Queue a requestShell · curl

curl --fail-with-body --silent --show-error \
  -X POST "https://api.raspbytes.com/api/v1/unblock/requests/" \
  -H "X-API-Key: $RASPBYTES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/products",
    "method": "GET",
    "strategy": "adaptive"
  }'

The asynchronous endpoint returns HTTP 202 with a request ID. Poll GET /api/v1/unblock/requests/{request_id}/ until the request reaches a terminal status.

List request history with GET /api/v1/unblock/requests/?page=1&page_size=25. The response includes count, next, previous, and results; page size is capped at 100.

Automatic proxy management is included.

Web Unblocker · Reference

Endpoints and retrieval modes

Automatic mode is recommended for most destinations. Select HTTP only or JavaScript rendering when the workload needs an explicit execution path.

POST/

Retrieve a page synchronously.

GET/entitlement/

Read the current entitlement and concurrency limit.

GET/requests/

List recent Web Unblocker requests.

POST/requests/

Queue a request for asynchronous retrieval.

GET/requests/{request_id}/

Read request status, result, usage, and attempts.

DELETE/requests/{request_id}/

Cancel a queued or running request.

HTTP only

standard

Use the fastest non-rendered retrieval path.

Automatic

adaptive

Render JavaScript only when the page requires it.

Render JavaScript

premium

Render from the start for JavaScript-heavy destinations.

SERP API

Return structured search results

Send a search query and receive normalised result data without building search-page parsers or managing the underlying retrieval workflow.

Discover

Read the enabled engines and searchable locations.

Search

Submit an immediate request or continue processing in the background.

Consume

Use the results object, including organic results, answer data, related searches, and pagination.

Base URLhttps://api.raspbytes.com/api/v1/serp

AuthenticationBearer or X-API-Key

Default engineGoogle Search

Search nowShell · curl

curl --fail-with-body --silent --show-error   -X POST "https://api.raspbytes.com/api/v1/serp/search/"   -H "X-API-Key: $RASPBYTES_API_KEY"   -H "Content-Type: application/json"   -d '{
    "engine": "google_search",
    "query": "coffee shops in London",
    "country": "gb",
    "language": "en",
    "device": "desktop",
    "page": 1,
    "results": 10
  }'

Queue a searchShell · curl

curl --fail-with-body --silent --show-error   -X POST "https://api.raspbytes.com/api/v1/serp/searches/"   -H "X-API-Key: $RASPBYTES_API_KEY"   -H "Content-Type: application/json"   -d '{
    "engine": "google_search",
    "query": "coffee shops in London",
    "country": "gb",
    "language": "en",
    "device": "desktop"
  }'

Delivery and permissions

Grant serp:write to run and cancel searches and serp:read to read search history, engines, locations, entitlements, and usage. Submit only entries returned in the engines array. Private-beta and planned engines are returned separately for discovery and are not accepted by public search requests. The search endpoint returns HTTP 200 when the result is ready or HTTP 202 when processing continues; use the returned request ID to retrieve the final result.

Completed resultJSON

{
  "id": "serp_req_123",
  "status": "completed",
  "engine": "google_search",
  "query": { "original": "coffee shops in London", "executed": "coffee shops in London" },
  "search_context": { "country": "gb", "language": "en", "device": "desktop", "page": 1, "results": 10 },
  "search_information": { "displayed_results": 10, "time_taken_ms": 842 },
  "results": {
    "organic_results": [{ "position": 1, "title": "Example", "link": "https://example.com" }],
    "ads": [],
    "answer_box": null,
    "knowledge_graph": null,
    "local_pack": null,
    "people_also_ask": [],
    "news_results": [],
    "image_results": [],
    "video_results": [],
    "shopping_results": [],
    "related_searches": []
  },
  "pagination": { "current_page": 1, "results_per_page": 10, "next_page": 2, "has_next_page": true }
}

Result responses contain customer-facing search data only. Every submission triggers a fresh upstream retrieval; parser, routing, and worker details remain internal. Failed searches return the same request context with a public error object instead of empty result sections.

SERP API · Reference

Search, discovery, and usage endpoints

Choose the search context and result shape; Raspbytes manages retrieval strategy automatically. Read engines and locations rather than hard-coding capabilities that may differ by account or environment.

POST/search/

Run a search and return the result immediately when it is ready.

GET/searches/

List search history; filter by status or engine and paginate the response.

POST/searches/

Submit a search for background processing.

GET/searches/{request_id}/

Read search status, request context, public usage, and errors.

GET/searches/{request_id}/result/

Read the structured result for a completed search.

DELETE/searches/{request_id}/

Cancel a queued or running search.

GET/engines/

List enabled engines, devices, languages, and result limits.

GET/locations/

Search supported locations by name and country.

GET/usage/

Read searches, request credits, response bytes, and success rate.

GET/entitlement/

Read the active allowance and concurrency limit.

Core search fields

engine

An engine returned in GET /engines/ under engines. google_search, bing_search, and duckduckgo_search provide production web results; private-beta and planned entries cannot be submitted.

query

The search query, up to 500 characters.

country

Two-letter country code used for search context; defaults to us.

location or location_id

Optional location targeting. Supply one, not both.

language

Supported language code; defaults to en.

device

desktop or mobile, when supported by the selected engine.

page and results

Page 1-10 and 1-100 requested results.

safe_search

Enable or disable safe-search filtering; defaults to true.

include_raw_html

Include the bounded source HTML in the result; defaults to false and is excluded from shared caching.

timeout_ms

Optional total execution budget from 1,000 to 120,000 milliseconds.

max_request_units

Optional request-unit ceiling from 1 to 100; retrieval strategy remains managed by Raspbytes.

Dataset API

Buy consistent, ready-to-use datasets

Choose a curated dataset, select its record volume, delivery frequency, and download option, then receive schema-validated immutable deliveries. Source collection stays internal.

Choose

Review offered datasets, volumes, prices, and normalized fields.

Configure

Select one-time or recurring delivery and a record volume.

Deliver

Receive one JSON, CSV, XLSX, or Parquet artifact by download or a saved destination.

Base URLhttps://api.raspbytes.com/api/v1

AuthenticationBearer or X-API-Key

Available formatsJSON · CSV · XLSX · Parquet

Discover dataset offersShell · curl

curl --fail-with-body --silent --show-error   "https://api.raspbytes.com/api/v1/dataset-offers/"

Buy a datasetShell · curl

curl --fail-with-body --silent --show-error   -X POST "https://api.raspbytes.com/api/v1/dataset-purchases/"   -H "X-API-Key: $RASPBYTES_API_KEY"   -H "Content-Type: application/json"   -d '{
    "offer": "uk-marketplace-products",
    "volume_records": 10000,
    "frequency": "weekly",
    "delivery_option": "download",
    "output_format": "parquet"
  }'

Internal collection

Raspbytes owns reviewed source URLs, crawling, browser rendering, extraction, normalization, refreshes, and quality gates. Customer requests never contain collection logic or JavaScript.

Offers and permissions

Grant dataset:write to create purchases and dataset:read to read offers, purchases, deliveries, and downloads.

Dataset API · Delivery

Choose a cadence and download delivery history

One-time, daily, weekly, and monthly selections consume versions from the internal collection pipeline. Delivery history keeps immutable artifact metadata and exposes fresh secure downloads.

Weekly purchaseJSON

{
  "offer": "uk-marketplace-products",
  "volume_records": 10000,
  "frequency": "weekly",
  "delivery_option": "download",
  "output_format": "csv"
}

Ready purchaseJSON

{
  "id": "dsp_123",
  "status": "active",
  "selection": {
    "volume_records": 10000,
    "frequency": "weekly",
    "delivery_option": "download",
    "output_format": "csv"
  },
  "deliveries": [{
    "id": "dsd_123",
    "dataset_version": "dsv_123",
    "record_count": 10000,
    "artifacts": [{ "id": "0", "format": "csv", "filename": "uk-marketplace-products-dsd_123.csv" }]
  }]
}

Frequency choices

one_time delivers the latest complete version once.
daily, weekly, and monthly receive eligible later versions.
Available choices are declared by each offer.

Download a completed artifact

Read a purchase delivery, take an artifact id, and request its download endpoint. The response returns a short-lived URL and filename.

GET /dataset-purchases/dsp_123/deliveries/dsd_123/artifacts/0/download/

Dataset API · Reference

Offers, purchases, deliveries, and downloads

Read available commercial choices before purchasing. Source URLs, connectors, selectors, retrieval policy, and target scripts remain private.

GET/dataset-offers/

List available datasets, volume prices, frequencies, delivery options, schemas, and fields.

GET/dataset-purchases/

Read cursor-paginated purchase and delivery history.

POST/dataset-purchases/

Purchase one advertised dataset configuration.

GET/dataset-purchases/{purchase_id}/

Read selections, status, price snapshot, versions, and artifacts.

GET/dataset-purchases/{purchase_id}/deliveries/{delivery_id}/artifacts/{artifact_id}/download/

Create a short-lived download for a delivered artifact.

Purchase fields

offer

Dataset slug advertised by GET /dataset-offers/.

volume_records

One exact record volume advertised by the selected offer.

frequency

one_time, daily, weekly, or monthly when supported by the offer.

delivery_option

An advertised delivery method: secure download, S3, Google Sheets, FTP, or SFTP.

output_format

Exactly one of json, csv, xlsx, or parquet.

idempotency_key

Optional key that safely replays the same purchase without creating a duplicate.

Troubleshooting

Resolve common API problems

Start with the HTTP status, structured error code, request ID, and the affected product. Never include a live API key, proxy password, or browser connection URL in support messages.

400A request field, product option, target, or execution setting is invalid or unavailable.

401The API key or connection credential is missing, invalid, or expired.

402The product requires an active entitlement or the relevant usage allowance is exhausted.

403The API key lacks the required product permission or an account policy rejected the request.

404The requested job, session, or result does not exist or belongs to another account.

407A proxy client did not send the returned proxy credentials correctly.

424The product accepted the request, but the target execution did not produce a successful result.

429The account concurrency or request-rate limit is active. Retry after capacity becomes available.

502 / 503The target or Raspbytes execution service is temporarily unavailable. Retry only when the response marks the error as retryable.

What to include when contacting support

Include the product, UTC timestamp, HTTP status, structured error code, and request_id or session ID. Remove API keys, proxy credentials, browser WebSocket URLs, cookies, and sensitive page content.

Build with Raspbytes.

Choose the API for the result you need

Proxies

Browser API

Web Unblocker

SERP API

Dataset API

One documentation home

Create an API key

Open Credentials

Create the key

Save it securely

Keep the key private

Create your first connection

From the dashboard

From the API

Choose the network that fits the workload

Residential Proxies

Datacenter Proxies

Create and connect to a Residential proxy

Create

Read

Connect

Handle the response

Choose the generated protocols

Create and connect to a Datacenter proxy

Create

Read

Connect

Handle the response

Choose the generated protocols

Proxy API endpoints and fields

Authentication

Create-connection request fields

Add targeting only when the workflow needs it

Set sticky duration from the available limits

Duration rules

Use the returned URL without modifying it

Launch a browser for automated workflows

Configure

Create

Connect

Browser API permissions

Create and wait for a browser session

Create-session fields

Read live options

Automatic country selection

Use the client that matches the returned protocol

Chromium

Firefox

Reconnect, terminate, and inspect usage

Lifecycle behaviour

Concurrency and traffic

Endpoints, response fields, and errors

Session response fields

Retrieve a page without managing proxy operations

Submit

Retrieve

Use

Permissions

Choose synchronous or asynchronous delivery

Endpoints and retrieval modes

HTTP only

Automatic

Render JavaScript

Return structured search results

Discover

Search

Consume

Delivery and permissions

Search, discovery, and usage endpoints

Core search fields

Buy consistent, ready-to-use datasets

Choose

Configure

Deliver

Internal collection

Offers and permissions

Choose a cadence and download delivery history

Frequency choices