# Vimeo Transcript Scraper (`automation-lab/vimeo-transcript-scraper`) Actor

Extract every public Vimeo caption track as clean transcript text and timestamped cues, with video and track metadata. No login or speech-to-text required.

- **URL**: https://apify.com/automation-lab/vimeo-transcript-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Videos, Automation, AI
- **Stats:** 1 total users, 1 monthly users, 75.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event + usage

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Vimeo Transcript Scraper

Extract captions and subtitles from public Vimeo videos as clean transcript text and timestamped cues.

[Vimeo Transcript Scraper](https://apify.com/automation-lab/vimeo-transcript-scraper) reads the text tracks already exposed by Vimeo's public player.

It does **not** invent a transcript, run speech-to-text, or require a Vimeo login.

Use it for localization, accessibility, media research, content analysis, and RAG ingestion.

### What does Vimeo Transcript Scraper do?

Give the Actor one or more public Vimeo video URLs or numeric IDs.

For every selected caption or subtitle track, it returns:

- 🎬 Vimeo video ID, canonical URL, and title
- 👤 Owner name and owner URL when Vimeo provides them
- ⏱️ Video duration and dimensions
- 🌐 Track language, label, kind, and provenance
- ✅ Whether Vimeo marks the track as default
- 🧩 Ordered `{ start, end, text }` cues in seconds
- 📝 A clean joined transcript
- 🔗 The signed source WebVTT URL
- 📄 The complete raw VTT document when requested

The source URL is signed and may expire, so save the transcript or raw VTT rather than treating that URL as permanent.

### Who is it for?

#### Accessibility teams

Audit which public Vimeo videos have captions and export timestamped text for remediation workflows.

#### Localization teams

Collect every language track, compare labels and provenance, and prepare subtitles for translation QA.

#### Researchers and media intelligence teams

Turn public captioned videos into searchable text while retaining time references to the source.

#### RAG and LLM engineers

Chunk transcripts using cue boundaries and store timestamps for grounded retrieval and source linking.

#### Content operations teams

Reuse approved captions in editorial systems, summaries, knowledge bases, and video catalogs.

### Why use this Vimeo transcript extractor?

- ⚡ **HTTP-first:** no browser boot or video download
- 🔐 **No credentials:** works on caption tracks exposed to anonymous viewers
- 🌍 **Multi-language:** extracts every track or exact language codes
- 🎯 **Track-level records:** preserves label, kind, provenance, and default state
- 🕒 **Timestamp grounding:** numeric start and end seconds are ready for code
- 🧾 **Structured gaps:** captionless videos are reported, never fabricated
- 💾 **Export ready:** use Apify datasets as JSON, CSV, Excel, or API responses

### What Vimeo data can I extract?

| Field | Type | Meaning |
|---|---|---|
| `videoId` | number | Vimeo's numeric video ID |
| `videoUrl` | string | Canonical public Vimeo URL |
| `inputUrl` | string | URL or ID supplied in the input |
| `title` | string | Video title from player configuration |
| `ownerName` | string | Vimeo owner name when available |
| `ownerUrl` | string | Owner URL when available |
| `durationSeconds` | number | Video duration in seconds |
| `width`, `height` | number | Source player dimensions |
| `status` | string | `ok`, `no_captions`, `language_not_found`, or `error` |
| `availableLanguages` | string[] | Every language code Vimeo exposes |
| `trackId` | number | Vimeo caption-track ID |
| `language` | string | Exact Vimeo language code |
| `label` | string | Human-readable track label |
| `kind` | string | Caption, subtitle, or related track kind |
| `provenance` | string | Uploaded or generated provenance when exposed |
| `isDefault` | boolean | Whether Vimeo marks the track as default |
| `cueCount` | number | Number of parsed timestamped cues |
| `cues` | object[] | Ordered start, end, and text objects |
| `transcript` | string | Clean joined transcript text |
| `sourceVttUrl` | string | Temporary signed source VTT URL |
| `rawVtt` | string | Optional complete WebVTT source |
| `scrapedAt` | string | ISO timestamp for extraction |

### How much does it cost to extract Vimeo transcripts?

This Actor uses pay per event pricing.

A **$0.005 start event** covers run initialization, then each saved transcript-track or structured video-status record is charged as one result.

The BRONZE result price is **$0.000099639** (about $0.0996 per 1,000 records). Current result prices are FREE $0.00011458, SILVER $0.000077718, GOLD $0.000059783, PLATINUM $0.000039856, and DIAMOND $0.000027899.

Because the Actor reads existing captions instead of downloading media or running ASR, it is designed for low compute use. A one-video run returning seven language tracks costs the start fee plus seven result events.

To estimate a batch, multiply your tier's result price by the number of selected caption tracks, then add $0.005.

### How to extract a Vimeo transcript

1. Open [Vimeo Transcript Scraper](https://apify.com/automation-lab/vimeo-transcript-scraper).
2. Paste one or more public Vimeo video URLs or IDs into **Vimeo video URLs or IDs**.
3. Leave **Language codes** empty to keep every track, or enter exact codes such as `en` or `pt`.
4. Enable **Include raw WebVTT** only when you need the original file content.
5. Click **Start**.
6. Open the default dataset to inspect transcript-track records.
7. Export JSON, CSV, Excel, or connect the dataset to your workflow.

### Input parameters

#### `videoUrls`

Required array with 1-100 entries.

Supported examples include:

- `https://vimeo.com/980152407`
- `https://player.vimeo.com/video/980152407`
- common Vimeo channel or group paths containing a numeric video ID
- a numeric string such as `980152407`

Non-Vimeo domains fail validation rather than being crawled.

#### `languageCodes`

Optional array of exact, case-insensitive Vimeo language codes.

An empty array extracts every available track.

If none match, the Actor emits `language_not_found` with `availableLanguages` so you can correct the filter.

#### `includeRawVtt`

Optional boolean, default `false`.

Enable it when preserving cue settings, headers, or original line breaks matters.

#### `maxConcurrency`

Optional integer from 1 to 10, default `5`.

Lower it when running large batches conservatively.

### Example input

```json
{
  "videoUrls": [
    "https://vimeo.com/980152407"
  ],
  "languageCodes": [
    "en-x-autogen"
  ],
  "includeRawVtt": false,
  "maxConcurrency": 1
}
````

To collect every language, omit `languageCodes` or set it to an empty array.

### Example output

```json
{
  "videoId": 980152407,
  "videoUrl": "https://vimeo.com/980152407",
  "inputUrl": "https://vimeo.com/980152407",
  "title": "How to add captions or subtitles to your video",
  "ownerName": "Vimeo",
  "durationSeconds": 142,
  "status": "ok",
  "availableLanguages": ["en-x-autogen", "pt", "fr"],
  "trackId": 182243678,
  "language": "en-x-autogen",
  "label": "English (auto-generated)",
  "kind": "captions",
  "provenance": "ai_generated",
  "isDefault": true,
  "cueCount": 36,
  "cues": [
    { "start": 1.935, "end": 4.045, "text": "Vimeo makes it easy to add captions" }
  ],
  "transcript": "Vimeo makes it easy to add captions ...",
  "sourceVttUrl": "https://captions.vimeo.com/captions/...vtt?...",
  "scrapedAt": "2026-07-22T00:00:00.000Z"
}
```

Signed source URLs are intentionally refreshed on every run.

### Understanding output statuses

#### `ok`

A selected track was fetched and parsed into at least one cue.

#### `no_captions`

The public player configuration exposed no caption or subtitle tracks.

This does not mean the Actor transcribed the audio; no speech-to-text is performed.

#### `language_not_found`

The video has tracks, but none match the requested language codes.

Check `availableLanguages` and rerun with one of those exact values.

#### `error`

The individual video could not be fetched or parsed.

If every requested video fails, the Actor run fails instead of returning a misleading success.

### Working with timestamped cues

Each cue has numeric `start` and `end` values measured in seconds.

That shape works well for:

- splitting long transcripts into time-bounded chunks
- creating deep links or chapter references
- aligning translated text with source timing
- finding the exact video moment behind a search result
- building subtitle quality checks

Cue text is stripped of WebVTT markup and common HTML entities are decoded.

The raw file remains available through `rawVtt` when enabled.

### Tips for reliable Vimeo caption extraction

- Use the exact public video or player URL visible to anonymous viewers.
- Include the unlisted `h` hash when Vimeo supplies one in the URL.
- Keep language filters empty on the first run to discover available codes.
- Save `rawVtt` if you need permanent source-file content.
- Do not store `sourceVttUrl` as a permanent download endpoint; it expires.
- Start with low concurrency for large external batches.
- Treat `no_captions` as a source-data fact, not a scraping failure.

### Export and integration workflows

#### Accessibility inventory

Schedule a run with a maintained list of public video URLs, then filter dataset records by `status` to find videos without captions.

#### Localization QA

Group records by `videoId`, compare `language`, `label`, `cueCount`, and `provenance`, then send differences to a review queue.

#### RAG ingestion

Map each cue into a document containing `videoId`, `start`, `end`, `text`, and `videoUrl` for timestamp-grounded retrieval.

#### Research archive

Export JSON with `includeRawVtt: true`, retain the scrape timestamp, and preserve both normalized and source representations.

#### Webhook automation

Use an Apify webhook to notify Make, Zapier, n8n, or your API when a run succeeds, then consume the default dataset.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/vimeo-transcript-scraper').call({
  videoUrls: ['https://vimeo.com/980152407'],
  languageCodes: ['en-x-autogen'],
  includeRawVtt: false,
  maxConcurrency: 1,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].transcript);
```

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/vimeo-transcript-scraper').call(run_input={
    'videoUrls': ['https://vimeo.com/980152407'],
    'languageCodes': ['en-x-autogen'],
    'includeRawVtt': False,
    'maxConcurrency': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[0]['transcript'])
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~vimeo-transcript-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "videoUrls": ["https://vimeo.com/980152407"],
    "languageCodes": ["en-x-autogen"],
    "includeRawVtt": false,
    "maxConcurrency": 1
  }'
```

After the run finishes, fetch items from its `defaultDatasetId`.

### Use Vimeo Transcript Scraper with MCP

Connect Apify MCP to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/vimeo-transcript-scraper"
```

For Claude Desktop, Cursor, or VS Code, add an HTTP MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/vimeo-transcript-scraper"
    }
  }
}
```

Example prompts:

- “Extract every public caption language from this Vimeo video.”
- “Get the English Vimeo transcript and return cues around mentions of accessibility.”
- “Prepare timestamped Vimeo caption chunks for my RAG pipeline.”
- “Check whether these Vimeo videos expose captions to anonymous viewers.”

### Scheduling and monitoring

Create an Apify schedule when the source list changes over time.

Use a stable input task containing your video URLs.

Send successful run events to a webhook, then compare `trackId`, `cueCount`, or transcript hashes in your own storage.

Vimeo signed URLs change, so compare track identity and content rather than signed URL strings.

### Limitations

- Only caption/subtitle tracks exposed by Vimeo's anonymous public player are available.
- Private and password-protected video access is not supported.
- The Actor does not download video or audio.
- The Actor does not perform Whisper, ASR, or any other speech-to-text.
- Caption quality depends on the uploader or Vimeo-generated source track.
- Signed VTT URLs expire.
- Vimeo can change its public player configuration.
- Language filtering uses exact source codes, not fuzzy language names.

### Is it legal to scrape Vimeo captions?

This Actor reads caption tracks exposed by public Vimeo player configuration.

Public accessibility does not remove copyright or license obligations.

Use the data only when you have a lawful purpose and the right to process the relevant video text.

Respect Vimeo's terms, the publisher's rights, privacy requirements, and applicable laws.

Do not use the Actor to bypass private access controls or redistribute copyrighted captions without permission.

This section is general information, not legal advice.

### Troubleshooting

#### Why did I get `no_captions`?

The anonymous Vimeo player did not expose any text tracks for that video.

The Actor never substitutes generated speech-to-text, so an empty source remains explicit.

#### Why did I get `language_not_found`?

Your filter did not exactly match Vimeo's language codes.

Read `availableLanguages` and use one of those values.

#### Why does the source VTT URL no longer work?

Vimeo signs caption URLs with an expiry.

Run the Actor again to refresh configuration, or enable `includeRawVtt` and save the source content in your dataset.

#### Why did the complete run fail?

The Actor fails when every requested video request fails, which prevents a false successful run.

Confirm that the URLs are public Vimeo video/player URLs and include any required unlisted hash.

### Frequently asked questions

#### Does this Actor transcribe videos without captions?

No. It extracts only caption and subtitle tracks Vimeo already exposes.

#### Can it extract every language?

Yes. Leave `languageCodes` empty and one dataset record is emitted per available track.

#### Can I use a numeric Vimeo ID?

Yes. Pass the ID as a string in `videoUrls`.

#### Does it need a Vimeo API token?

No token is required for the supported anonymous public-caption scope.

#### Can it return the original VTT?

Yes. Set `includeRawVtt` to `true`.

#### Are timestamps strings or numbers?

Parsed cues use numeric seconds for easier filtering and computation.

### Related video scrapers

- [YouTube Transcript](https://apify.com/automation-lab/youtube-transcript) — extract transcript data from YouTube sources.
- [Video Transcript Scraper](https://apify.com/automation-lab/video-transcript-scraper) — use a broader transcript workflow when Vimeo-specific track metadata is not required.
- [TikTok Transcript Scraper](https://apify.com/automation-lab/tiktok-transcript-scraper) — collect transcript data from TikTok videos.

Choose Vimeo Transcript Scraper when you need Vimeo-native caption tracks, language metadata, provenance, and timestamped cues without media transcription.

### Start extracting Vimeo transcripts

Open [Vimeo Transcript Scraper](https://apify.com/automation-lab/vimeo-transcript-scraper), paste one public video URL, and keep the prefilled low-concurrency settings for a quick first run.

Export the resulting transcript records or connect them directly to your accessibility, localization, research, or RAG workflow.

# Actor input Schema

## `videoUrls` (type: `array`):

Add public vimeo.com or player.vimeo.com video URLs, or numeric Vimeo video IDs. Up to 100 per run.

## `languageCodes` (type: `array`):

Optionally keep exact Vimeo language codes such as en, en-US, or pt. Leave empty to extract every available track.

## `includeRawVtt` (type: `boolean`):

Store the complete source VTT document in rawVtt in addition to parsed cues and clean transcript text.

## `maxConcurrency` (type: `integer`):

Limit simultaneous player-config requests. Lower this value if Vimeo throttles a large batch.

## Actor input object example

```json
{
  "videoUrls": [
    "https://vimeo.com/980152407"
  ],
  "languageCodes": [],
  "includeRawVtt": false,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `overview` (type: `string`):

API URL for transcript tracks with video metadata, language, cues, clean text, and source details.

# 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 = {
    "videoUrls": [
        "https://vimeo.com/980152407"
    ],
    "languageCodes": [],
    "includeRawVtt": false,
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/vimeo-transcript-scraper").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 = {
    "videoUrls": ["https://vimeo.com/980152407"],
    "languageCodes": [],
    "includeRawVtt": False,
    "maxConcurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/vimeo-transcript-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "videoUrls": [
    "https://vimeo.com/980152407"
  ],
  "languageCodes": [],
  "includeRawVtt": false,
  "maxConcurrency": 5
}' |
apify call automation-lab/vimeo-transcript-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/vimeo-transcript-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vimeo Transcript Scraper",
        "description": "Extract every public Vimeo caption track as clean transcript text and timestamped cues, with video and track metadata. No login or speech-to-text required.",
        "version": "0.1",
        "x-build-id": "CIaYgFn16wfSxlbVX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~vimeo-transcript-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-vimeo-transcript-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~vimeo-transcript-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-vimeo-transcript-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~vimeo-transcript-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-vimeo-transcript-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "videoUrls"
                ],
                "properties": {
                    "videoUrls": {
                        "title": "🎬 Vimeo video URLs or IDs",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add public vimeo.com or player.vimeo.com video URLs, or numeric Vimeo video IDs. Up to 100 per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "languageCodes": {
                        "title": "🌐 Language codes",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optionally keep exact Vimeo language codes such as en, en-US, or pt. Leave empty to extract every available track.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "includeRawVtt": {
                        "title": "📄 Include raw WebVTT",
                        "type": "boolean",
                        "description": "Store the complete source VTT document in rawVtt in addition to parsed cues and clean transcript text.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "⚡ Maximum concurrent videos",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Limit simultaneous player-config requests. Lower this value if Vimeo throttles a large batch.",
                        "default": 5
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```