RapidAPI Screenshot API: Marketplace vs Direct API

ScreenshotRun is available on RapidAPI. You can subscribe through the marketplace and use your existing RapidAPI key to capture screenshots without creating a separate account. For quick prototyping or teams already billing through RapidAPI, that path works.

But RapidAPI's proxy adds 800-1,500ms to every request. The 25% platform cut means higher prices or lower quotas. And the marketplace format limits which parameters a provider can surface. If you need the full 40+ parameter set and lower latency without the pricing markup, calling the ScreenshotRun API directly is the stronger option. This page covers both approaches with code for each.

How RapidAPI screenshot APIs work

RapidAPI is an API marketplace. You subscribe to a provider's plan and get a unified API key. All requests go through RapidAPI's proxy to reach the actual provider. Every request carries two headers instead of a standard Bearer token:

const axios = require("axios");

const response = await axios({
  method: "GET",
  url: "https://some-screenshot-api.p.rapidapi.com/capture",
  params: {
    url: "https://example.com",
    width: 1280,
    format: "png",
  },
  headers: {
    "X-RapidAPI-Key": "YOUR_RAPIDAPI_KEY",
    "X-RapidAPI-Host": "some-screenshot-api.p.rapidapi.com",
  },
  responseType: "arraybuffer",
});

That .p.rapidapi.com domain is RapidAPI's proxy. Your request hits their servers first, gets authenticated against your subscription, then forwards to the actual screenshot provider. The response comes back the same way. That double hop is where the extra latency comes from.

The same screenshot through ScreenshotRun directly

Same result, fewer layers. Standard Bearer token, direct connection to the rendering cluster, no middleman proxy:

const axios = require("axios");

const response = await axios({
  method: "GET",
  url: "https://api.screenshotrun.com/v1/screenshots/capture",
  params: {
    url: "https://example.com",
    width: 1280,
    format: "png",
    full_page: true,
    block_cookies: true,
  },
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
  },
  responseType: "arraybuffer",
});

Two things jump out. First, the auth is a standard Authorization: Bearer header that every HTTP library handles natively. No RapidAPI-specific headers. Second, the params object already includes full_page and block_cookies. Most RapidAPI screenshot APIs don't expose parameters beyond url, width, height, and format.

What RapidAPI screenshot APIs are missing

Browse the RapidAPI screenshot collection and you will notice a pattern. Most listings — ScreenshotOne, Restpack, Pikwy, URL To Screenshot — share the same limitation: a handful of basic parameters. Even the ScreenshotRun listing on RapidAPI exposes a subset of what the direct API offers. The table below shows the gap.

The gap isn't about one missing feature. What happens when you try to capture pages you don't control? Ad overlays cover the content. Cookie banners block the viewport. Cloudflare challenges replace the page with a CAPTCHA. Content renders differently in Germany than in Japan. Without content blocking or stealth mode, you are limited to capturing your own sites or unprotected pages. Geolocation is off the table entirely.

How much latency does the RapidAPI proxy add?

Measurable overhead. Every request goes through their authentication layer and rate limiter before reaching the actual API. The routing infrastructure adds its own overhead on top. Users on RapidAPI community forums report 1,200-1,800ms for requests that take 250ms when called directly.

For a screenshot API, this matters more than for most APIs. The response payload is a multi-megabyte image, not a small JSON object. The proxy has to receive the full image from the provider, then stream it back to you. On a 3MB full-page PNG, the extra round trip is noticeable. Multiply that by a batch of 50 URLs and you have added over a minute of pure proxy overhead to your pipeline.

Pricing without the marketplace cut

RapidAPI takes 25% of every dollar the API provider earns (raised from 20% in November 2025). Plus payment processing fees of around 3%. Providers pass that cost through in one of two ways: higher prices per screenshot, or lower quotas on free tiers.

Compare the free tiers directly:

What does that mean at scale? A provider charging $20/month on RapidAPI keeps about $14 after the platform cut. To maintain the same margin, they either charge more or give you less. With a direct API, there is no middleman. The price you pay goes entirely toward the service you are using.

When RapidAPI makes sense

The RapidAPI listing exists for a reason. If your project already calls eight RapidAPI services, adding ScreenshotRun through the same dashboard keeps your integration layer simple. One API key, one invoice, basic screenshots without a separate signup.

Evaluation is another strength. You can test four screenshot APIs in an afternoon without creating four separate accounts. RapidAPI's testing playground lets you send requests from the browser and compare responses. For quick prototyping, that convenience has value.

Where it stops making sense: production workloads where latency matters, batch pipelines where the proxy overhead compounds, any workflow that needs the full parameter set. If you need stealth mode to capture protected pages or geolocation for brand monitoring across regions, switch to the direct API. Same goes for certified timestamps in legal evidence workflows.

Switching from RapidAPI to the direct API

Migration takes about two minutes. Replace the endpoint URL and swap the two RapidAPI headers for a single Bearer token. Everything else in your code stays the same.

Before (RapidAPI):

const response = await axios({
  method: "GET",
  url: "https://some-screenshot-api.p.rapidapi.com/capture",
  params: { url: targetUrl, width: 1280, format: "png" },
  headers: {
    "X-RapidAPI-Key": process.env.RAPIDAPI_KEY,
    "X-RapidAPI-Host": "some-screenshot-api.p.rapidapi.com",
  },
  responseType: "arraybuffer",
});

After (ScreenshotRun direct):

const response = await axios({
  method: "GET",
  url: "https://api.screenshotrun.com/v1/screenshots/capture",
  params: {
    url: targetUrl,
    width: 1280,
    format: "png",
    full_page: true,
    block_cookies: true,
    block_ads: true,
  },
  headers: {
    Authorization: `Bearer ${process.env.SCREENSHOTRUN_API_KEY}`,
  },
  responseType: "arraybuffer",
});

Response format is identical. Both return image bytes when you set responseType: "arraybuffer". Your downstream code that processes the image buffer does not need to change at all.

Python migration example

Same pattern in Python. Replace the URL and headers, add any extra parameters you want:

import requests

# Before — through RapidAPI
response = requests.get(
    "https://some-screenshot-api.p.rapidapi.com/capture",
    params={"url": "https://example.com", "width": 1280},
    headers={
        "X-RapidAPI-Key": RAPIDAPI_KEY,
        "X-RapidAPI-Host": "some-screenshot-api.p.rapidapi.com",
    },
)

# After — ScreenshotRun direct
response = requests.get(
    "https://api.screenshotrun.com/v1/screenshots/capture",
    params={
        "url": "https://example.com",
        "width": 1280,
        "format": "webp",
        "full_page": "true",
        "block_cookies": "true",
        "stealth": "true",
    },
    headers={"Authorization": f"Bearer {SCREENSHOTRUN_API_KEY}"},
)

with open("screenshot.webp", "wb") as f:
    f.write(response.content)

Notice the extra parameters in the direct version. Stealth mode and cookie blocking were not available through the RapidAPI proxy. After migrating, you get the full parameter set without switching providers again.

Advanced parameters available after migration

Once you are calling ScreenshotRun directly, every API parameter is available. The ones that matter most for developers coming from RapidAPI's limited parameter sets:

params: {
  url: "https://example.com",
  format: "webp",            // AVIF and TIFF also available
  width: 1280,
  full_page: true,
  block_cookies: true,       // consent banners gone
  block_ads: true,           // ad overlays removed
  block_chats: true,         // chat widgets hidden
  dark_mode: true,           // prefers-color-scheme: dark
  stealth: true,             // bypass bot detection
  geolocation: "de",         // capture from Germany
  delay: 3000,               // wait for dynamic content
  css: ".popup { display: none; }",
  certified: true,           // RFC 3161 timestamp
  response_type: "json",     // hosted URL instead of binary
}

Most of these parameters are not available through the RapidAPI proxy version. If you have been working around limitations by injecting JavaScript through other means, or post-processing screenshots to crop out overlays, these built-in parameters eliminate that extra code.

For the full parameter reference, check the feature pages. Language-specific integration guides are available for Node.js, Python, PHP, Go, and eight more languages. Sign up and the API key is ready in seconds.

FAQ#