Name: ayushunleashed Screenshot Kit Website Screenshot API
Brand: magicapi
SKU: api-magicapi-screenshot-screen-recording-api-ayushunleashed-screenshot-kit
Availability: InStock
Author: API Market

Shashank Agarwal

# 📸 Website Screenshot and Screen Recording API (ayushunleashed Screenshot Kit)

![Website Screenshot and Screen Recording API (ayushunleashed Screenshot Kit) on api.market](https://blog.api.market/wp-content/uploads/2026/10/ayushunleashed__screenshot-kit-cover-api-market.jpg)

## Overview
Screenshot Kit captures a web page as an image or as a scrolling screen recording. Its developer describes it as a tool to take a screenshot or screen recording of any website. This version is published by ayushunleashed.

Send a `url` and choose `action`: `screenshot` returns one image file (png, jpeg or webp), `video` returns a video of the page scrolling for `video_duration` seconds. The output is a single file URL.

## Features
- **Two capture modes**: `action` `screenshot` (default) or `video`.
- **Viewport presets**: `device` `desktop` (default), `phone`, or `custom` with your own `width` and `height`.
- **Full page screenshots**: `full_page` captures the whole scrollable page instead of only the visible viewport.
- **Screen recordings**: `video_duration` (0.1 to 30 seconds, default 10) and `scroll_speed` (at least 50 pixels per second, default 300) control the recording.
- **Load strategy**: `wait_until` waits for `load` (default), `domcontentloaded`, `networkidle`, or a fixed `wait_time` in seconds when set to `time`.
- **Image format and quality**: `image_format` `png` (default), `jpeg` or `webp`, with `image_quality` 1 to 100 for jpeg and webp.

## Use Cases
1. **Link previews and thumbnails**: capture a page image to show next to a link.
2. **Visual monitoring**: take regular screenshots of your own pages to spot layout changes.
3. **Mobile checks**: capture a page with the `phone` preset to see the mobile layout.
4. **Product walkthrough clips**: record a short scrolling video of a landing page for demos or social posts.

## Visual Examples
### Example Input
URL: `https://example.com` (a public placeholder page)

Settings: `action` `video`, `device` `phone`, `full_page` `false`, `wait_until` `load`, `image_format` `png`, `scroll_speed` `300`, `video_duration` `10`.

### Example Output
A 10-second recording of the page in the phone viewport: [Watch the example output](https://blog.api.market/wp-content/uploads/2026/10/screenshot-kit-output-bjpgsx34-api-market.mp4)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `url` | string | No | a sample website |  | Website URL to capture. Always send the page you want; if omitted, a sample website is captured |
| `action` | string | No | `screenshot` | `screenshot`, `video` | Capture mode |
| `device` | string | No | `desktop` | `desktop`, `phone`, `custom` | Viewport size preset |
| `width` | integer | No | none |  | Custom viewport width (only when `device` is `custom`) |
| `height` | integer | No | none |  | Custom viewport height (only when `device` is `custom`) |
| `full_page` | boolean | No | `false` |  | Capture the full scrollable page |
| `image_format` | string | No | `png` | `png`, `jpeg`, `webp` | Screenshot image format |
| `image_quality` | integer | No | none | 1 to 100 | Image quality for jpeg and webp |
| `video_duration` | number | No | `10` | 0.1 to 30 | Video recording duration in seconds |
| `scroll_speed` | number | No | `300` | minimum 50 | Scroll speed in pixels per second |
| `wait_until` | string | No | `load` | `load`, `domcontentloaded`, `networkidle`, `time` | Page load strategy |
| `wait_time` | number | No | none | minimum 0.1 | Wait duration in seconds (when `wait_until` is `time`) |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.0024 per API unit.
- **1 API unit = 1 request with up to 19 seconds of processing.** A request that runs longer is billed one more unit for each started 19-second block (for example, more than 19 and up to 38 seconds of processing is 2 units, $0.0048).
- Processing time includes page loading and, for `video`, the recording itself, so a recording takes at least `video_duration` seconds.
- **Example cost**: the example request (a 10-second `video` recording) took 11.1 seconds of processing, which fits in one 19-second block: 1 API unit, $0.0024.
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/screenshot-screen-recording-api-ayushunleashed-screenshot-kit`

### Authentication
Send your api.market API key in the `x-api-market-key` header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 1 second and an overall timeout of 600 seconds (10 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/screenshot-screen-recording-api-ayushunleashed-screenshot-kit/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "b1e1f27f93d3fdfbf92cf484ae3cda8a2a9b5d71ae246596db07849858247f0a",
    "input": {
      "url": "https://example.com",
      "action": "video",
      "device": "phone",
      "full_page": false,
      "wait_until": "load",
      "image_format": "png",
      "scroll_speed": 300,
      "video_duration": 10
    }
  }'
```

Response (201 Created):
```json
{
  "id": "bjpgsx3475rmy0d1f4w8k7yqjm",
  "version": "b1e1f27f93d3fdfbf92cf484ae3cda8a2a9b5d71ae246596db07849858247f0a",
  "status": "starting",
  "created_at": "2026-10-26T17:18:21.388Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/screenshot-screen-recording-api-ayushunleashed-screenshot-kit/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "bjpgsx3475rmy0d1f4w8k7yqjm",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/screenshot-kit-output-bjpgsx34-api-market.mp4",
  "error": null,
  "created_at": "2026-10-26T17:18:21.388Z",
  "started_at": "2026-10-26T17:18:21.401Z",
  "completed_at": "2026-10-26T17:18:32.466Z"
}
```

`output` is a single URL string: an image in `image_format` for `screenshot`, or a video file for `video`. In our test run the live API returned the recording as a WebM file; the example above links our MP4 copy of it.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a `video_duration` above 30 or an `action` that is not `screenshot` or `video`.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits
Requests are rate limited to keep usage fair. If you receive a 429 response, wait and retry with exponential backoff.

## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`, for example when the page cannot be reached; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/screenshot-screen-recording-api-ayushunleashed-screenshot-kit";

async function createAndWaitForPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "b1e1f27f93d3fdfbf92cf484ae3cda8a2a9b5d71ae246596db07849858247f0a", input })
  });

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 600000;
  const pollInterval = 1000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    await delay(pollInterval);
  }

  throw new Error("Prediction timed out after 10 minutes");
}

createAndWaitForPrediction({
  "url": "https://example.com",
  "action": "video",
  "device": "phone",
  "full_page": false,
  "wait_until": "load",
  "image_format": "png",
  "scroll_speed": 300,
  "video_duration": 10
}).then((output) => console.log(output));
```

#### Python
```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/screenshot-screen-recording-api-ayushunleashed-screenshot-kit"


def create_and_wait_for_prediction(input_data):
    headers = {"Content-Type": "application/json", "x-api-market-key": API_KEY}
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "b1e1f27f93d3fdfbf92cf484ae3cda8a2a9b5d71ae246596db07849858247f0a", "input": input_data},
    )

    if response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])


def poll_for_results(prediction_id):
    max_timeout = 600
    poll_interval = 1
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < max_timeout:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers=headers)

        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]

        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

    raise Exception("Prediction timed out after 10 minutes")


output = create_and_wait_for_prediction({
    "url": "https://example.com",
    "action": "video",
    "device": "phone",
    "full_page": False,
    "wait_until": "load",
    "image_format": "png",
    "scroll_speed": 300,
    "video_duration": 10
})
print(output)
```

## FAQ
- **How do I take a still screenshot instead of a video?**
  - Set `action` to `screenshot` (the default) and pick `image_format`. Add `full_page: true` to capture the whole scrollable page.
- **How do I set my own screen size?**
  - Set `device` to `custom` and send `width` and `height` in pixels. With `desktop` or `phone`, `width` and `height` are ignored.
- **The page is captured before its content appears. What can I do?**
  - Set `wait_until` to `networkidle`, or set it to `time` and send `wait_time` in seconds to wait a fixed time after loading.
- **How long can a recording be, and what does it cost?**
  - Up to 30 seconds (`video_duration`). A recording takes at least its duration to process, billed one unit per started 19 seconds; the 10-second example took 11.1 seconds, 1 unit, $0.0024.
- **Can it capture pages behind a login?**
  - The schema has no fields for cookies, headers or credentials, so only publicly reachable pages can be captured.
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, check that the URL is reachable, and try again.

## Contact Us
If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.


Take full-page or viewport website screenshots, or scrolling screen recordings up to 30 seconds, with Screenshot Kit. $0.0024 per request.