# Viagogo Tickets Listings Scraper (`stealth_mode/viagogo-tickets-listings-scraper`) Actor

Scrape live ticket listings from Viagogo with 87+ data fields including seat details, pricing, section maps, and seller information. Perfect for market research, price monitoring, and ticket data analysis across sports, music, and entertainment events.

- **URL**: https://apify.com/stealth\_mode/viagogo-tickets-listings-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, News
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

## Viagogo Tickets Scraper: Extract Listings & Pricing Data in Seconds

---

### What Is Viagogo?

Viagogo is one of the world's largest ticket resale marketplaces, connecting millions of buyers and sellers of tickets for sports, music, and entertainment events. Thousands of listings update daily with varying prices, seat locations, and seller terms. Manually collecting this data across multiple events and sellers is tedious and error-prone — the **Viagogo Tickets Scraper** automates extraction, delivering clean, structured ticket data ready for analysis.

---

### Overview

The **Viagogo Tickets Listings Scraper** extracts comprehensive ticket listing data from Viagogo event pages, capturing detailed information about available tickets, pricing tiers, seat locations, seller metrics, and deal indicators. It is ideal for:

- **Ticket resellers** monitoring market prices and inventory trends
- **Event promoters** tracking secondary market demand and competition
- **Data analysts** building datasets for pricing research
- **Aggregator platforms** integrating Viagogo data into comparison tools
- **Researchers** studying ticket market dynamics

The scraper handles multiple listings per event, respects site policies with intelligent retry logic, and gracefully manages failures without interrupting bulk runs.

---

### Input Format

The scraper accepts a JSON configuration with three core parameters:

```json
{
  "urls": [
    "https://www.viagogo.com/Sports-Tickets/WWE/WWE-Raw-Tickets/E-160524024?quantity=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

| Parameter | Type | Description |
|---|---|---|
| `urls` | Array | Direct links to Viagogo event listing pages. Paste the full URL including event ID and any query parameters (e.g., `?quantity=2`). |
| `ignore_url_failures` | Boolean | If `true`, the scraper continues processing remaining URLs if some fail to load. Useful for bulk runs. Set to `false` to halt on first error. |
| `max_items_per_url` | Integer | Maximum ticket listings to extract per URL (e.g., `200` captures up to 200 different seller offers for the same event). Higher values take longer. |

> **Tip:** Use the full event URL from your browser address bar. Event IDs (like `E-160524024`) are required for accurate data retrieval.

***

### Output Format

**Sample output**

```json
{
  "id": 12942233114,
  "event_id": 160524024,
  "section": "Upper Tier B",
  "section_id": 1179967,
  "section_map_name": "Upper Tier B",
  "section_type": 2,
  "row": "Ok",
  "seat": "_",
  "seat_from_internal": "",
  "has_seat_details": false,
  "has_seat_details_us": null,
  "available_tickets": 4,
  "formatted_fees": "",
  "grid_listing_price_and_fee_disclosure": {
    "has_value": false
  },
  "is_all_in_grid_listing_price_and_fee_disclosure": null,
  "inventory_listing_score": {
    "star_rating": 3,
    "deal_score": "6.594746516852883",
    "seat_quality_score": "0.7206024635"
  },
  "show_recently_sold": null,
  "show_partnership_logo": null,
  "show_clear_view": null,
  "available_quantities": [
    1,
    2,
    3,
    4
  ],
  "ticket_class": 267,
  "ticket_class_name": "Upper Tier",
  "max_quantity": 4,
  "has_listing_notes": null,
  "listing_notes": [
    {
      "listing_note_id": -1,
      "listing_note_content_id": 3338094,
      "formatted_listing_note_content": "Clear view",
      "listing_note_type_id": 3,
      "show_to_buyer": true,
      "hide_in_mock": false,
      "site_added_listing_note": false,
      "aisle_listing_note_with_split": false,
      "listing_note_description_content_id": 3338095,
      "formatted_listing_note_description": "You'll have an unrestricted view of the show."
    }
  ],
  "listing_note_buckets": [
    {
      "listing_note_bucket_id": 26,
      "formatted_listing_note_content": "Clear view",
      "display_order": 8,
      "shows_raw_note_text": true,
      "source_listing_note_id": -1
    }
  ],
  "row_id": null,
  "is_users_listing": null,
  "is_pre_uploaded": null,
  "row_content": null,
  "is_speculative_row": null,
  "raw_price": 68.9,
  "price": "$69",
  "formatted_total_price": "$138",
  "strike_through_price": null,
  "strike_through_discount_percent": null,
  "strike_through_amount_off": null,
  "strike_through_price_default_currency": null,
  "ticket_type_id": null,
  "ticket_type_name": "Mobile Transfer ticket",
  "ticket_type_group_id": null,
  "listing_type_id": null,
  "listing_currency_code": null,
  "buyer_currency_code": null,
  "face_value": 62.0,
  "face_value_currency_code": null,
  "vfs_url": "https://img.vggcdn.net/img/vfsimage2/787893/267_1179967/0.jpg?im=Resize=(500,271)&v=100",
  "formatted_active_since": null,
  "formatted_deal_score": null,
  "is_seated_together": null,
  "show_vfs_in_listing": null,
  "hide_seat_and_row_info": null,
  "is_unmapped_section": null,
  "aip_hash": null,
  "is_mlb_verified": null,
  "created_date_time": "2026-06-05T12:45:57.4600000Z",
  "show_cheapest_tag": null,
  "show_best_deal_tag": null,
  "show_best_deal_in_section_tag": null,
  "show_best_view_tag": null,
  "show_top_choice_tag": null,
  "top_choice_bucket": null,
  "is_most_affordable": null,
  "listing_ranking_score": null,
  "is_zone_ticket_class": null,
  "is_sponsored": null,
  "is_sponsored_secondary": null,
  "is_mirror_listing": null,
  "cross_sell_source": null,
  "is_cheapest_listing": null,
  "is_favorite": null,
  "aggregate_favorites": null,
  "listing_id": 12942233114,
  "can_be_relisted": null,
  "listing_impression_id": "EB240992-4063-4504-BFBB-16ED3B8F8611",
  "is_better_value_listing": null,
  "has_row_level_vfs": null,
  "is_deal_score_eligible_for_display": null,
  "listing_highlight_data": {
    "highlight_site_messages_with_type": [
      {
        "message": "Popular Pick",
        "qualifier": "10 people viewed this event in the past hour",
        "has_value": true,
        "message_type": "NumberOfViewsSocialProofBased"
      }
    ],
    "listing_note_ids_replaced_by_highlight": []
  },
  "from_url": "https://www.viagogo.com/Sports-Tickets/WWE/WWE-Raw-Tickets/E-160524024?quantity=2"
}
```

Each ticket listing returns a rich record with 87+ fields across multiple categories:

#### Ticket & Seat Information

| Field | Meaning |
|---|---|
| `ID` | Unique internal listing identifier in Viagogo's system |
| `Event ID` | The event this ticket is for (e.g., WWE Raw show) |
| `Section` | Named seating section (e.g., "Section 104", "Lower Bowl") |
| `Section ID` | Internal ID for the section in the venue map |
| `Section Map Name` | Display name for the section on the venue map |
| `Section Type` | Category of the section (e.g., "Lower", "Upper", "Club") |
| `Row` | Row designation within the section (e.g., "A", "B", "15") |
| `Seat` | Individual seat number (e.g., "105", "2-4") |
| `Seat From Internal` | Internal seat designation for verification |
| `Has Seat Details` | Boolean: whether the listing includes detailed seat mapping |
| `Has Seat Details US` | Boolean: US-specific seat detail availability |
| `Is Seated Together` | Boolean: confirms if multiple tickets are consecutive seats |
| `Hide Seat And Row Info` | Boolean: seller chose to hide exact seat information |
| `Is Unmapped Section` | Boolean: section exists but lacks a venue map |

#### Inventory & Availability

| Field | Meaning |
|---|---|
| `Available Tickets` | Number of tickets currently available in this listing |
| `Available Quantities` | Array of available quantity options (e.g., \[1, 2, 4]) |
| `Ticket Class` | Internal ticket classification code |
| `Ticket Class Name` | Human-readable ticket tier (e.g., "Premium", "Standard") |
| `Max Quantity` | Maximum tickets a single buyer can purchase from this listing |
| `Is Zone Ticket Class` | Boolean: listing is a zone ticket (not specific seats) |
| `Ticket Type ID` | Classification of ticket type in the system |
| `Ticket Type Name` | Name of ticket type (e.g., "General Admission") |
| `Ticket Type Group ID` | Grouping ID for similar ticket types |

#### Pricing Data

| Field | Meaning |
|---|---|
| `Price` | Base ticket price (per ticket, before fees) |
| `Formatted Total Price` | Total cost formatted for display (includes all fees) |
| `Formatted Fees` | Processing and service fees broken down and formatted |
| `Strike Through Price` | Original higher price used for "discount" displays |
| `Strike Through Discount Percent` | Discount percentage vs. struck price |
| `Strike Through Amount Off` | Dollar/currency amount of discount |
| `Strike Through Price Default Currency` | Currency for the struck price |
| `Raw Price` | Raw numeric price value before formatting |
| `Face Value` | Original face value printed on the ticket |
| `Face Value Currency Code` | Currency of face value (e.g., "USD", "GBP") |
| `Listing Currency Code` | Currency the seller lists the ticket in |
| `Buyer Currency Code` | Currency shown to the buyer (may differ if international) |

#### Seller & Listing Metadata

| Field | Meaning |
|---|---|
| `Listing ID` | Unique identifier for this specific listing |
| `Listing Type ID` | Category of listing (e.g., resale, official) |
| `Is Users Listing` | Boolean: seller is an individual (not a broker) |
| `Is Pre Uploaded` | Boolean: seller pre-loaded inventory before sales began |
| `Is Mirror Listing` | Boolean: duplicate listing mirrored from another source |
| `Cross Sell Source` | Where the listing originated (e.g., internal, affiliate) |
| `Created Date Time` | When this listing was posted |
| `Formatted Active Since` | How long the listing has been active (formatted string) |
| `Formatted Listing Notes` | Seller notes about the tickets (e.g., "Transfer fee applies") |
| `Listing Notes` | Raw text of seller notes |
| `Listing Note Buckets` | Categorized seller note types |
| `Has Listing Notes` | Boolean: seller provided notes or restrictions |

#### Scoring & Deal Indicators

| Field | Meaning |
|---|---|
| `Inventory Listing Score` | Internal score measuring listing quality (0-100) |
| `Listing Ranking Score` | Position score affecting search result ranking |
| `Deal Score` | Formatted display of the deal value (e.g., "Great Deal") |
| `Formatted Deal Score` | Human-readable version of the deal score |
| `Is Deal Score Eligible For Display` | Boolean: deal score meets display criteria |
| `Show Cheapest Tag` | Boolean: display "Cheapest" badge if applicable |
| `Is Cheapest Listing` | Boolean: this is the lowest-priced listing for the event |
| `Show Best Deal Tag` | Boolean: display "Best Deal" badge |
| `Is Better Value Listing` | Boolean: offers good value relative to price and quality |
| `Show Best Deal In Section Tag` | Boolean: best deal within the specific section |
| `Show Best View Tag` | Boolean: highlighting for excellent seat view |
| `Show Most Affordable Tag` | Boolean: good for budget-conscious buyers |
| `Is Most Affordable` | Boolean: among the cheapest available |
| `Show Top Choice Tag` | Boolean: popular with buyers in this section |
| `Top Choice Bucket` | Ranking tier for "Top Choice" designation |

#### Verification & Trust Signals

| Field | Meaning |
|---|---|
| `Is MLB Verified` | Boolean: MLB (Major League Baseball) verified listing |
| `VFS URL` | Viagogo Fraud Score URL for transparency |
| `Show VFS In Listing` | Boolean: display fraud score to buyers |
| `Has Row Level VFS` | Boolean: fraud score available at row level |
| `AIP Hash` | Anti-fraud verification hash |

#### Listing Display & Engagement

| Field | Meaning |
|---|---|
| `Is Favorite` | Boolean: current user has favorited this listing |
| `Aggregate Favorites` | Total count of users who favorited this listing |
| `Listing Impression ID` | Tracking ID for analytics and impressions |
| `Grid Listing Price And Fee Disclosure` | Price/fee summary shown in listing grid |
| `Is All In Grid Listing Price And Fee Disclosure` | Boolean: all costs visible in grid view |
| `Show Clear View` | Boolean: highlight "Clear View" benefits |
| `Show Partnership Logo` | Boolean: display partner/vendor logo |
| `Show Recently Sold` | Boolean: indicate recent sales to create urgency |
| `Row Content` | Formatted display content for the row |

#### Special Listing Types & Status

| Field | Meaning |
|---|---|
| `Is Speculative Row` | Boolean: estimated/speculative inventory |
| `Is Sponsored` | Boolean: listing has paid promotion |
| `Is Sponsored Secondary` | Boolean: secondary-tier sponsored listing |
| `Row ID` | Database ID for the listing row |
| `Can Be Relisted` | Boolean: seller can relist these tickets |
| `Listing Highlight Data` | Additional formatting/highlight metadata |

***

### How to Use

1. **Find event URLs** — Navigate to Viagogo.com, search for an event, and open the listings page. Copy the URL from your browser (e.g., `https://www.viagogo.com/Sports-Tickets/WWE/WWE-Raw-Tickets/E-160524024?quantity=2`).

2. **Configure input** — Paste the URL(s) into the `urls` array. For multiple events, add each URL as a separate line. Set `max_items_per_url` based on needs (e.g., `200` for comprehensive market data, `50` for quick samples).

3. **Handle failures** — Set `ignore_url_failures: true` for bulk scraping to skip unreachable pages without stopping the entire run.

4. **Run the scraper** — Start the actor and monitor progress in the logs.

5. **Export & analyze** — Download results as JSON, CSV, or Excel. Use the pricing and scoring fields to identify trends, compare sellers, or feed data into dashboards.

**Common tips:**

- Full event URLs work best; avoid shortened or bookmark links.
- Pricing updates in real time, so re-run for current market conditions.
- The `max_items_per_url` limit prevents excessive slowdown; adjust based on event size.
- Filter output by `Show Cheapest Tag` or `Deal Score` fields to identify market opportunities.

***

### Use Cases & Business Value

- **Price monitoring:** Track Viagogo ticket prices over time for specific events or venues
- **Market research:** Analyze ticket demand, seller competition, and geographic pricing variations
- **Reseller intelligence:** Monitor competitor listings and adjust pricing strategies
- **Event analytics:** Understand secondary market dynamics for new or historical events
- **Aggregation:** Integrate Viagogo data into ticket comparison platforms or bots
- **Fraud detection:** Use aggregated listing data to spot unusual patterns or suspicious sellers

The Viagogo Tickets Scraper transforms raw marketplace data into actionable insights, enabling data-driven decisions in the competitive ticket resale ecosystem.

***

### Conclusion

The **Viagogo Tickets Listings Scraper** is a powerful tool for anyone needing structured ticket market data. With 87+ fields capturing pricing, seat details, seller metrics, and deal scores, it eliminates hours of manual monitoring and enables sophisticated analysis. Whether you're a reseller optimizing prices, a researcher studying ticket markets, or a developer building aggregation tools, this scraper delivers the data you need at scale.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the tickets listings urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.viagogo.com/Sports-Tickets/WWE/WWE-Raw-Tickets/E-160524024?quantity=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.viagogo.com/Sports-Tickets/WWE/WWE-Raw-Tickets/E-160524024?quantity=2"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/viagogo-tickets-listings-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 = {
    "urls": ["https://www.viagogo.com/Sports-Tickets/WWE/WWE-Raw-Tickets/E-160524024?quantity=2"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/viagogo-tickets-listings-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 '{
  "urls": [
    "https://www.viagogo.com/Sports-Tickets/WWE/WWE-Raw-Tickets/E-160524024?quantity=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/viagogo-tickets-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=stealth_mode/viagogo-tickets-listings-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Viagogo Tickets Listings Scraper",
        "description": "Scrape live ticket listings from Viagogo with 87+ data fields including seat details, pricing, section maps, and seller information. Perfect for market research, price monitoring, and ticket data analysis across sports, music, and entertainment events.",
        "version": "0.0",
        "x-build-id": "T9Vmgd90Z5MmnbjbO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~viagogo-tickets-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-viagogo-tickets-listings-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/stealth_mode~viagogo-tickets-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-viagogo-tickets-listings-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/stealth_mode~viagogo-tickets-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-viagogo-tickets-listings-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",
                "properties": {
                    "urls": {
                        "title": "URLs of the tickets listings urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the tickets listings urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
