# Loom Scraper (`automation-lab/loom-scraper`) Actor
Extract Loom video transcripts, metadata, and direct download URLs. All-in-one: transcript with timestamps + owner/view data + MP4 URL. Pure HTTP — fast and cheap. No API key needed.
- **URL**: https://apify.com/automation-lab/loom-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media, Videos
- **Stats:** 101 total users, 35 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars
## Pricing
Pay per event
This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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
## Loom Scraper
Extract **transcripts, metadata, and direct download URLs** from Loom videos — no API key, no Loom account, no browser needed. Paste any public Loom share URL and get structured data in seconds.
### What does Loom Scraper do?
Loom Scraper is an **all-in-one data extraction tool** for [Loom](https://www.loom.com), the async video messaging platform used by millions of B2B teams. It accesses Loom's public GraphQL API directly (pure HTTP — no Playwright, no headless browser) to extract:
- 📝 **Full transcripts** with per-segment timestamps (`startSeconds`, `endSeconds`, `text`) and full concatenated plain text for LLM pipelines
- 📊 **Video metadata** — title, description, duration, owner, view count, comment count, emoji count, thumbnail URL
- 🎬 **Direct MP4 download URLs** (signed CDN URLs, download promptly)
- 🔒 Works on all public Loom share URLs — no authentication required
Batch-process hundreds of Loom videos in a single run. All competitors are FREE and single-purpose — this actor is the **only all-in-one Loom extractor** on the Apify Store.
### Who is it for?
#### 📚 Documentation & Knowledge Teams
Content teams who receive Loom walkthroughs from engineers, designers, or sales reps and need to convert video narration into written docs, wikis, or SOPs. Instead of watching hours of video, extract all transcripts in bulk and feed them into your documentation workflow.
#### 🤖 AI / LLM Developers
Builders creating RAG pipelines, AI meeting summarizers, or video-to-document converters. Loom Scraper gives you clean, timestamped transcript text ready to pass to GPT-4, Claude, or Gemini without manual copy-paste.
#### 📋 Compliance & Archiving Teams
Legal, HR, and compliance teams that need to archive video communications for audit trails, e-discovery, or regulatory requirements. Extract and store transcript text and metadata for all shared Looms in your organization.
#### 🔁 Workflow Automation Engineers
Engineers building CI/CD workflows that automatically process new Loom videos — trigger on new video URL → extract transcript → post to Slack, create Jira ticket, or update Confluence page.
#### 📈 Sales & Marketing Analysts
Teams analyzing sales demo recordings or marketing explainer videos to extract talking points, review competitor content, or build training datasets from existing video libraries.
### Why use Loom Scraper?
- ✅ **All-in-one** — transcript + metadata + download URL in a single run (no competitor does all three)
- ✅ **Pure HTTP** — no browser overhead, runs in 256 MB, blazing fast
- ✅ **No API key required** — works with any public Loom share URL
- ✅ **Bulk processing** — process hundreds of videos in one run
- ✅ **LLM-ready output** — `transcriptText` field gives plain text ready for AI pipelines
- ✅ **Timestamped segments** — `transcript` array has `startSeconds`/`endSeconds`/`text` for each caption block
- ✅ **Apify platform** — schedule runs, export to CSV/JSON/Excel, connect to 5,000+ apps via Zapier/Make
- ✅ **API access** — integrate into any workflow via REST API, Node.js, or Python SDK
### What data can you extract?
| Field | Description |
|-------|-------------|
| `id` | Loom video ID (32-char hex) |
| `url` | Full share URL |
| `title` | Video title |
| `description` | Video description (if set) |
| `privacy` | Visibility: `public`, `private`, etc. |
| `durationSeconds` | Duration in seconds |
| `durationMs` | Duration in milliseconds |
| `createdAt` | ISO 8601 creation timestamp |
| `updatedAt` | ISO 8601 last-updated timestamp |
| `ownerId` | Owner's Loom user ID |
| `ownerName` | Owner's display name |
| `ownerEmail` | Owner's email (if publicly visible) |
| `thumbnailUrl` | Thumbnail image URL |
| `viewCount` | Total view count |
| `distinctViewCount` | Unique viewer count |
| `emojiCount` | Total emoji reactions |
| `commentCount` | Total comment count |
| `width` | Video width in pixels |
| `height` | Video height in pixels |
| `videoUrl` | Signed MP4 direct download URL |
| `transcriptStatus` | `success`, `unavailable`, or `null` |
| `transcript` | Array of `{startSeconds, endSeconds, text}` segments |
| `transcriptText` | Full transcript as a single plain-text string |
| `scrapedAt` | ISO 8601 timestamp of extraction |
### How much does it cost to scrape Loom videos?
This actor uses **pay-per-event** (PPE) pricing — you pay only for what you extract.
| Tier | Per video (`video-extracted`) | Actor start (flat, once per run) |
|------|-------------------------------|----------------------------------|
| **FREE** | $0.01035 | $0.02 |
| **BRONZE** | $0.009 | $0.02 |
| **SILVER** | $0.00702 | $0.02 |
| **GOLD** | $0.0054 | $0.02 |
| **PLATINUM** | $0.0036 | $0.02 |
| **DIAMOND** | $0.00252 | $0.02 |
**Real-world cost examples (FREE tier, $0.01035/video + $0.02/run):**
| Task | Videos | Runs | Approx. Cost |
|------|--------|------|--------------|
| Quick transcript check | 1 | 1 | ~$0.030 |
| Weekly team video archive | 20 | 1 | ~$0.227 |
| Bulk knowledge base build | 100 | 1 | ~$1.055 |
With $5 free credits, you can extract roughly **400–475 videos** in batch runs (e.g. 4–5 runs of 100 videos each), or about **164 videos** if running one video per run.
### How to scrape Loom videos
1. **Go to the [Loom Scraper page](https://apify.com/automation-lab/loom-scraper)** on Apify Store
2. Click **Try for free**
3. In the **Videos** section, add one or more Loom share URLs (e.g. `https://www.loom.com/share/abc123...`)
4. Choose what to extract: **transcript**, **metadata**, and/or **video download URL**
5. Click **Save & Run**
6. Download results as **JSON, CSV, or Excel** — or connect directly to your app via API
**Example input:**
```json
{
"videoUrls": [
"https://www.loom.com/share/002508e86fde4232bb8de474eb5c65c4",
"https://www.loom.com/share/0054b03fe58a40ea960ef2e48a333667"
],
"extractTranscript": true,
"extractMetadata": true,
"extractVideoUrl": true,
"includeFullTranscriptText": true
}
````
**Metadata-only mode (fastest):**
```json
{
"videoUrls": ["https://www.loom.com/share/002508e86fde4232bb8de474eb5c65c4"],
"extractTranscript": false,
"extractMetadata": true,
"extractVideoUrl": false
}
```
### Input parameters
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `videoUrls` | Array | required | List of Loom share URLs to extract |
| `extractTranscript` | Boolean | `true` | Extract timed transcript segments |
| `extractMetadata` | Boolean | `true` | Extract title, owner, views, duration, etc. |
| `extractVideoUrl` | Boolean | `true` | Extract signed MP4 download URL |
| `includeFullTranscriptText` | Boolean | `true` | Include full transcript as plain text string |
### Output examples
**Single video with full transcript:**
```json
{
"id": "002508e86fde4232bb8de474eb5c65c4",
"url": "https://www.loom.com/share/002508e86fde4232bb8de474eb5c65c4",
"title": "Screen and engagement tips",
"description": null,
"privacy": "public",
"durationSeconds": 154,
"durationMs": 154000,
"createdAt": "2022-08-05T21:16:35.487Z",
"ownerName": "Miguel Acero",
"ownerEmail": "",
"thumbnailUrl": "https://cdn.loom.com/sessions/thumbnails/002508e86fde4232bb8de474eb5c65c4-1659734506699.jpg",
"viewCount": 94895,
"distinctViewCount": 88557,
"emojiCount": 5144,
"commentCount": 477,
"width": 1152,
"height": 720,
"videoUrl": "https://cdn.loom.com/sessions/transcoded/002508e86fde...mp4?Policy=...",
"transcriptStatus": "success",
"transcript": [
{ "startSeconds": 0.31, "endSeconds": 4.56, "text": "Hey, Loom community..." },
{ "startSeconds": 4.71, "endSeconds": 9.20, "text": "that supports agents..." }
],
"transcriptText": "Hey, Loom community... that supports agents...",
"scrapedAt": "2026-03-31T03:00:00.000Z"
}
```
### Tips for best results
- 🔗 **Use share URLs** — always use `https://www.loom.com/share/VIDEO_ID` format (32-character hex ID)
- ⚡ **Start small** — test with 1-2 URLs first to verify output before bulk runs
- 📥 **Download video URLs promptly** — signed MP4 URLs expire within a few hours
- 💾 **Transcript-only mode** — if you only need transcripts, disable `extractVideoUrl` for slightly faster runs
- 🤖 **LLM integration** — use `transcriptText` for direct GPT/Claude input; use `transcript` array when you need timestamps
- 📅 **Schedule recurring runs** — set up daily runs to archive new Looms automatically via Apify scheduling
- 🔒 **Private videos** — this actor only works on public Loom videos. Password-protected or private videos will return null
### Integrations
#### 🗂️ Loom → Google Sheets (documentation pipeline)
Connect Loom Scraper to Google Sheets via Zapier. Every time you run the scraper, transcript text and metadata are automatically added as new rows — building a searchable video archive without manual copy-paste.
#### 🤖 Loom → OpenAI/Claude (AI summarization)
Feed `transcriptText` output directly into a Make.com or n8n scenario that calls GPT-4 or Claude API. Generate summaries, action items, or key points from Loom walkthroughs automatically.
#### 📬 Loom → Slack (team digest)
Schedule a daily Apify run on a batch of Loom URLs, then post a digest of titles + transcript excerpts to your team's Slack channel. Great for async standups and knowledge sharing.
#### 🗄️ Loom → Notion/Confluence (knowledge base)
Use webhooks: when a Loom run completes, a webhook triggers a Make scenario that creates a Notion page or Confluence article with the transcript, title, and thumbnail — turning every Loom into a searchable text document.
#### ♻️ Scheduled archiving workflow
Set up a scheduled Apify run (daily or weekly) with a list of Loom share URLs. Combined with Apify's dataset export, this builds an automatic rolling archive of all your shared Looms.
### API usage
#### Node.js
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('automation-lab/loom-scraper').call({
videoUrls: [
'https://www.loom.com/share/002508e86fde4232bb8de474eb5c65c4',
],
extractTranscript: true,
extractMetadata: true,
extractVideoUrl: true,
includeFullTranscriptText: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].transcriptText);
```
#### Python
```python
from apify_client import ApifyClient
client = ApifyClient(token="YOUR_API_TOKEN")
run = client.actor("automation-lab/loom-scraper").call(run_input={
"videoUrls": [
"https://www.loom.com/share/002508e86fde4232bb8de474eb5c65c4",
],
"extractTranscript": True,
"extractMetadata": True,
"extractVideoUrl": True,
"includeFullTranscriptText": True,
})
items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(items[0]["transcriptText"])
```
#### cURL
```bash
curl -X POST https://api.apify.com/v2/acts/automation-lab~loom-scraper/runs \
-H "Authorization: Bearer YOUR_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"videoUrls": ["https://www.loom.com/share/002508e86fde4232bb8de474eb5c65c4"],
"extractTranscript": true,
"extractMetadata": true,
"extractVideoUrl": true
}'
```
### Use with AI agents via MCP
Loom Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).
Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:
#### Setup for Claude Code
```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```
#### Setup for Claude Desktop, Cursor, or VS Code
Add this to your MCP config file:
```json
{
"mcpServers": {
"apify": {
"url": "https://mcp.apify.com"
}
}
}
```
Your AI assistant will use OAuth to authenticate with your Apify account on first use.
#### Example prompts
Once connected, try asking your AI assistant:
- "Use automation-lab/loom-scraper to extract the transcript from https://www.loom.com/share/002508e86fde4232bb8de474eb5c65c4 and summarize the key points"
- "Get all the metadata from this Loom video and tell me how many people watched it"
- "Extract the transcripts from these 5 Loom videos and compile them into a single document"
Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).
### Legality
Loom Scraper only accesses **publicly shared videos** — videos that the owner explicitly made available via a share link. It does not bypass any authentication, access private workspaces, or circumvent any access controls.
Web scraping of publicly accessible content is generally legal in most jurisdictions. The [hiQ v. LinkedIn ruling](https://en.wikipedia.org/wiki/HiQ_Labs_v._LinkedIn) and similar cases have established that scraping publicly available data does not violate the Computer Fraud and Abuse Act (CFAA).
**Always ensure you have permission** to collect and use the video content and transcripts you extract. Respect intellectual property rights. This actor is intended for legitimate business use cases such as documentation, archiving, and AI pipeline development.
### FAQ
**How fast is the scraper?**
Very fast — pure HTTP, no browser. Each video takes 2-5 seconds to process (metadata + transcript). A batch of 100 videos typically completes in 3-5 minutes.
**How much does it cost per video?**
On the FREE tier: ~$0.030 per video ($0.02 actor-start fee + $0.01035 per video). Lower tiers get cheaper per-video rates — down to $0.00252 on DIAMOND. See the pricing section above for full tier details.
**Does it work without a Loom account?**
Yes. No account or API key required. The actor uses Loom's public GraphQL API which accepts anonymous requests for public videos.
**Is this faster than competitor scrapers?**
Yes. Most competitor Loom scrapers use Playwright (headless browser), which adds 30-60 seconds of startup time and 512-1024 MB memory. This actor uses pure HTTP and runs in 256 MB in 2-5 seconds per video.
**Why are some transcripts missing?**
Some Loom videos do not have transcripts — either because the owner disabled transcription, the video was recorded before Loom added AI transcription, or the transcription failed during processing. The `transcriptStatus` field will show `unavailable` in these cases. Metadata (title, duration, views, etc.) is still extracted.
**Why is the videoUrl empty for some videos?**
Signed CDN URLs are generated fresh each run. If a video has restricted downloads (owner disabled downloading), `videoUrl` may return `null`. The `downloadable` property in the underlying Loom API controls this per video.
**My video URL returned no results — what's wrong?**
Check that the URL is in the format `https://www.loom.com/share/VIDEO_ID` where `VIDEO_ID` is a 32-character hex string. Videos must be publicly shared (not password-protected or private). If a public video returns no results, the video may have been deleted.
### Related actors
- [YouTube Scraper](https://apify.com/automation-lab/youtube-scraper) — scrape YouTube videos, channels, comments
- [Vimeo Scraper](https://apify.com/automation-lab/vimeo-scraper) — extract Vimeo video data and metadata
- [TikTok Scraper](https://apify.com/automation-lab/tiktok-scraper) — scrape TikTok profiles, videos, hashtags
- [Instagram Scraper](https://apify.com/automation-lab/instagram-scraper) — extract Instagram posts, reels, profiles
# Actor input Schema
## `videoUrls` (type: `array`):
Add Loom share URLs to extract. Each URL must be in the format https://www.loom.com/share/VIDEO\_ID.
## `extractTranscript` (type: `boolean`):
Extract the full video transcript with timestamps. Returns an array of timed caption segments.
## `extractMetadata` (type: `boolean`):
Extract video metadata: title, description, owner, duration, view count, comment count, and thumbnail URL.
## `extractVideoUrl` (type: `boolean`):
Extract a signed direct MP4 download URL for the video. URLs expire after a short period — download promptly.
## `includeFullTranscriptText` (type: `boolean`):
In addition to timed segments, include the entire transcript concatenated as a single transcriptText string. Useful for LLM processing.
## Actor input object example
```json
{
"videoUrls": [
"https://www.loom.com/share/002508e86fde4232bb8de474eb5c65c4"
],
"extractTranscript": true,
"extractMetadata": true,
"extractVideoUrl": true,
"includeFullTranscriptText": true
}
```
# Actor output Schema
## `overview` (type: `string`):
No description
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"videoUrls": [
"https://www.loom.com/share/002508e86fde4232bb8de474eb5c65c4"
]
};
// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/loom-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = { "videoUrls": ["https://www.loom.com/share/002508e86fde4232bb8de474eb5c65c4"] }
# Run the Actor and wait for it to finish
run = client.actor("automation-lab/loom-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://www.loom.com/share/002508e86fde4232bb8de474eb5c65c4"
]
}' |
apify call automation-lab/loom-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=automation-lab/loom-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Loom Scraper",
"description": "Extract Loom video transcripts, metadata, and direct download URLs. All-in-one: transcript with timestamps + owner/view data + MP4 URL. Pure HTTP — fast and cheap. No API key needed.",
"version": "0.1",
"x-build-id": "8bT5ycVEpbNqpmCLG"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/automation-lab~loom-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-automation-lab-loom-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~loom-scraper/runs": {
"post": {
"operationId": "runs-sync-automation-lab-loom-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~loom-scraper/run-sync": {
"post": {
"operationId": "run-sync-automation-lab-loom-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": "🎬 Video URLs",
"type": "array",
"description": "Add Loom share URLs to extract. Each URL must be in the format https://www.loom.com/share/VIDEO_ID.",
"items": {
"type": "string"
}
},
"extractTranscript": {
"title": "Extract transcript",
"type": "boolean",
"description": "Extract the full video transcript with timestamps. Returns an array of timed caption segments.",
"default": true
},
"extractMetadata": {
"title": "Extract metadata",
"type": "boolean",
"description": "Extract video metadata: title, description, owner, duration, view count, comment count, and thumbnail URL.",
"default": true
},
"extractVideoUrl": {
"title": "Extract direct video URL",
"type": "boolean",
"description": "Extract a signed direct MP4 download URL for the video. URLs expire after a short period — download promptly.",
"default": true
},
"includeFullTranscriptText": {
"title": "Include full transcript as plain text",
"type": "boolean",
"description": "In addition to timed segments, include the entire transcript concatenated as a single transcriptText string. Useful for LLM processing.",
"default": true
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```