# Screenshot API (`skillforge99/screenshot-api`) Actor

Capture a screenshot of any URL (PNG, JPEG, or WebP) via a thin proxy over render.skillforge99.com. Pay only for successful renders.

- **URL**: https://apify.com/skillforge99/screenshot-api.md
- **Developed by:** [Skillforge 99](https://apify.com/skillforge99) (community)
- **Categories:** AI, Agents, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 screenshots

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Screenshot API

Capture a screenshot of any public URL and get back a PNG, JPEG, or WebP
image plus a direct download link. Point it at a page, get an image back.

### What it does

1. You give it a URL (and optionally a viewport size, full-page flag, and
   output format).
2. It renders the page and returns the image as the run's OUTPUT, with a
   direct link to it in the dataset.
3. That's it. No crawling, no page-follow, one URL in and one image out.

### Pricing

Pay per event (PPE): you are charged one `screenshot` event only when a
render succeeds. A failed render (bad URL, timeout, backend error) is never
charged. The per-event price is $0.0008 ($0.80 per 1,000 screenshots), set
at publication on the Actor's Apify Store page; check that page for the
current rate before running at volume, since it can change after launch.

### Usage examples

**1. Apify Console**

Open the Actor, fill in the input form (URL is the only required field),
click **Start**. When the run finishes, open the **OUTPUT** file on the
run's Storage tab to see the image, or download it from the link shown in
the dataset row.

**2. Apify API**

```bash
curl "https://api.apify.com/v2/acts/YOUR_USERNAME~screenshot-api/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com",
    "fullPage": true,
    "width": 1280,
    "height": 800,
    "format": "png"
  }'
```

The response is the dataset item: `{ url, imageUrl, width, height,
fullPage, format, units }`. `imageUrl` is a direct link to the image.

**3. Scheduled runs**

In the Apify Console, open the Actor, go to **Schedules**, create a new
schedule with a cron expression (for example `0 6 * * *` for daily at
06:00 UTC) and the same input you'd use for a manual run. Useful for a
daily screenshot of a dashboard, landing page, or competitor's homepage.

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `url` | string | (required) | The page to screenshot. |
| `fullPage` | boolean | `false` | Capture the full scrollable page instead of just the viewport. |
| `width` | integer | `1280` | Viewport width in pixels, 320-1920. |
| `height` | integer | `800` | Viewport height in pixels, 240-1080. |
| `format` | string | `png` | One of `png`, `jpeg`, `webp`. |

### Limits (honest, please read before relying on this at scale)

- Viewport size is bounded to 320-1920 px wide and 240-1080 px tall. Values
  outside that range are rejected by the input form; there is no way to
  render a larger or smaller viewport through this Actor.
- The backend that renders your request enforces a rate limit of 60
  requests per minute per API key. This Actor uses a shared backend key
  across all of its runs, so heavy concurrent use by many callers at once
  can hit that ceiling; a rate-limited run fails and is not charged, and
  is safe to retry after a short wait.
- This is a thin proxy to a single-page renderer: no JavaScript-heavy SPA
  wait-condition tuning, no multi-page crawling, no proxy/geo selection.
  If a page needs a long time to finish loading dynamic content, capture
  quality can vary.
- Pages behind a login wall, CAPTCHA, or bot-blocking will not render
  correctly; this tool does not attempt to bypass any of that.

### Support

Something not working as documented? Email vadim@skillforge99.com with the
run ID and the input you used.

### Affiliation

This Actor is an independent, third-party tool built for use with Apify's
platform. It is not affiliated with, endorsed by, or sponsored by Apify or
any website it is used to screenshot.

# Actor input Schema

## `url` (type: `string`):

The web page to screenshot.

## `fullPage` (type: `boolean`):

Capture the full scrollable page instead of just the visible viewport.

## `width` (type: `integer`):

Viewport width in pixels.

## `height` (type: `integer`):

Viewport height in pixels.

## `format` (type: `string`):

Output image format.

## Actor input object example

```json
{
  "url": "https://example.com",
  "fullPage": false,
  "width": 1280,
  "height": 800,
  "format": "png"
}
```

# Actor output Schema

## `screenshot` (type: `string`):

Direct download link to the captured screenshot (PNG, JPEG, or WebP, per the requested format), saved as the run's OUTPUT record.

## `results` (type: `string`):

Dataset item with the page URL, image link, dimensions, format, and units billed.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "url": "https://example.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("skillforge99/screenshot-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "url": "https://example.com" }

# Run the Actor and wait for it to finish
run = client.actor("skillforge99/screenshot-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "url": "https://example.com"
}' |
apify call skillforge99/screenshot-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,skillforge99/screenshot-api"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/kAJEGdulDrwOk3dzz/builds/fT8q3oHghbnWqyHWS/openapi.json