# Competitor Price Tracker & Monitor (`fayoussef/competitor-price-tracker-monitor`) Actor

Paste any product URL and instantly find top store selling the same item. PriceRadar returns each competitor's price, your market rank, gap vs. cheapest, gap vs. average, and a suggested pricing action. Works on Amazon, eBay, Walmart, Shopify & more. Export to CSV, Excel, JSON, or API.

- **URL**: https://apify.com/fayoussef/competitor-price-tracker-monitor.md
- **Developed by:** [youssef farhan](https://apify.com/fayoussef) (community)
- **Categories:** E-commerce, Automation, AI
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Competitor Price Tracker & Monitor — Compare Any Product URL Across the Web

Competitor price tracker that takes any product URL and finds every other retailer selling the same item, their live price, your rank in the market, and a suggested pricing action. Built for ecommerce sellers, brand managers, repricing teams, and MAP-policy enforcement who need to know *who else sells this and for how much* without searching Google by hand. Unlike Google Shopping scrapers, it returns verified product matches (UPC/EAN/GTIN + AI confirmation), drops mismatched-currency prices instead of guessing, and streams one clean row per competitor.

Paste a link from **Amazon, Walmart, Target, Best Buy, eBay, Fnac, Shopify, WooCommerce** or any independent store. The competitor price monitor handles the search, fetch, matching, and math for you.

### What you get

One row per `(reference product, matched competitor)`. Reference identity and market aggregates repeat on every row so any column is sortable and filterable.

**Reference product**
- `reference_url` — the product URL you supplied.
- `reference_title` — product name from the reference page.
- `reference_brand` — brand extracted from the page.
- `reference_model` — model / variant name.
- `reference_identifiers` — JSON of UPC/EAN/GTIN/MPN codes found.
- `reference_price` — your current price.
- `reference_currency` — ISO-4217 currency code.
- `reference_availability` — in-stock status.

**Market aggregate**
- `matches_found` — confirmed competitor matches for this product.
- `urls_checked` — SERP candidates fetched and classified.
- `min_comp_price` / `avg_comp_price` / `max_comp_price` — competitor price distribution.
- `your_rank` — your position from cheapest to most expensive.
- `price_position` — Cheapest in market / Below market avg / Above market avg / Most expensive.
- `pct_vs_avg_market` — signed % difference vs the market average.
- `pct_vs_cheapest` — signed % difference vs the cheapest competitor.
- `suggested_action` — plain-English pricing move (e.g. *Room to raise price toward avg*).

**Per competitor**
- `competitor_domain` — retailer domain.
- `competitor_url` — direct link to the competitor listing.
- `competitor_product_name` — title on the competitor page.
- `comp_price` / `comp_currency` — competitor price.
- `comp_vs_you_abs` — price difference vs you, absolute.
- `comp_vs_you_pct` — price difference vs you, percent.
- `market_rank` — this competitor's rank (1 = cheapest).
- `confidence` — match confidence (high / medium / low).
- `shipping_rules` — shipping terms found on the page.
- `reasoning` — why this URL was confirmed as a match.
- `is_cheapest` — true if this is the cheapest match.
- `status` — `OK` / `No matches` / error string.

### Sample output

```json
{
  "reference_url": "https://www.amazon.com/dp/B08N5WRWNW",
  "reference_title": "Echo Dot (4th Gen) Smart Speaker with Alexa",
  "reference_brand": "Amazon",
  "reference_model": "Echo Dot 4th Gen",
  "reference_identifiers": "{\"UPC\": \"840268945237\", \"MPN\": \"B08N5WRWNW\"}",
  "reference_price": 49.99,
  "reference_currency": "USD",
  "reference_availability": "In Stock",
  "matches_found": 4,
  "urls_checked": 18,
  "min_comp_price": 44.95,
  "avg_comp_price": 51.20,
  "max_comp_price": 59.99,
  "your_rank": 2,
  "price_position": "Below market avg",
  "pct_vs_avg_market": -2.36,
  "pct_vs_cheapest": 11.21,
  "suggested_action": "Room to raise price toward avg",
  "competitor_domain": "walmart.com",
  "competitor_url": "https://www.walmart.com/ip/Echo-Dot-4th-Gen/586352757",
  "competitor_product_name": "Amazon Echo Dot (4th Gen) Smart Speaker",
  "comp_price": 44.95,
  "comp_currency": "USD",
  "comp_vs_you_abs": -5.04,
  "comp_vs_you_pct": -10.08,
  "market_rank": 1,
  "confidence": "high",
  "shipping_rules": "Free shipping over $35",
  "reasoning": "Same brand, model, and UPC 840268945237 confirmed on page.",
  "is_cheapest": true,
  "status": "OK"
}
````

### Use cases

- ✓ Ecommerce sellers tracking competitor prices on Amazon and Walmart for their own SKUs
- ✓ Repricing teams flagging any retailer undercutting their floor price
- ✓ Brand managers enforcing MAP policy and spotting unauthorized resellers
- ✓ Dropshippers and arbitrage buyers finding the cheapest supplier per product
- ✓ Market researchers capturing the full price distribution, not just the top 3 results
- ✓ AI agents answering "what's the cheapest price online for X?" with fresh, grounded data

### How it works

- **Input:** one or more canonical product URLs (e.g. `https://www.amazon.com/dp/B08N5WRWNW`). Each runs in parallel.
- **Search:** Google SERP per product, optionally narrowed to `includedDomains` and filtered against a social/review blocklist.
- **Match:** structured-data-first extraction, AI pre-filter, then fetch + AI classification with UPC/EAN/GTIN confirmation.
- **Output:** one row per confirmed competitor, streamed live to the Apify dataset — exportable to JSON, CSV, Excel, or the API.
- **Scheduling & webhooks:** run daily/hourly via Apify Schedules and push changes to Slack, Sheets, or your DB via webhooks.

### Why this scraper

- **Verified matches, not lookalikes** — UPC/EAN/GTIN + AI confirmation, not fuzzy title guessing.
- **Currency-safe** — competitor prices in other currencies are dropped, never silently converted, so your numbers stay comparable.
- **Major retailers covered** — Amazon, Walmart, Target, Best Buy, eBay, Fnac and Cloudflare-protected stores via the scrape.do integration below.
- **Resumable** — re-running the same input picks up where it stopped, so no credits are wasted.
- **Decision-ready** — every row carries your rank, % vs market, and a suggested action.

### The Scraper API Key (read this)

Without a Scraper API Key, the competitor price tracker fetches sites through residential proxy only. That works for small and mid-size shops but is reliably blocked by Amazon, Walmart, Target, Best Buy, Fnac, and eBay — you will get empty results for those.

Get a free key (1,000 credits/month) here: **https://scrape.do/?fpr=automationbyexperts** — sign up, copy the token, paste it into `scrapedoApiKey`.

### Input example

```json
{
  "productUrls": [
    { "url": "https://www.amazon.com/dp/B08N5WRWNW" }
  ],
  "scrapedoApiKey": "YOUR_SCRAPEDO_TOKEN",
  "country": "us",
  "currency": "USD",
  "maxCompetitors": 10,
  "maxPages": 2
}
```

Omit `includedDomains` to search the whole web, or set it to compare against a fixed list of retailers only.

### FAQ

**How does it get past anti-bot protection?**
Residential proxies for general stores, and the scrape.do API for Amazon, Walmart, Target, Best Buy, eBay and Cloudflare-protected sites.

**What output formats are supported?**
JSON, CSV, Excel, and XML — exportable from the dataset tab or the Apify API.

**Are the prices live or cached?**
Live. Every run fetches each competitor page in real time.

**Does it work outside the US?**
Yes. Set `country` to any ISO code (`gb`, `de`, `fr`, `ca`, `au`, …) — both Google geo-targeting and the residential proxy follow.

**Can I restrict which retailers it checks?**
Yes. Fill `includedDomains` to whitelist domains, or `excludedDomains` to skip ones that waste retries.

**Can I track my own Shopify or WooCommerce store?**
Yes. Any public product URL works as the reference input.

**Can I schedule it?**
Yes. Use Apify Schedules for daily/hourly runs and webhooks to push changes downstream.

**Can I call it from an AI agent?**
Yes — see the next section.

### Use via API or MCP

Run the competitor price monitor from any backend via the Apify REST API, or wire it into an AI agent (Claude, ChatGPT, Cursor) as an MCP server for grounded, real-time price answers.

```
POST https://api.apify.com/v2/acts/[PLACEHOLDER: slug~actor]/runs?token=YOUR_TOKEN
```

```
https://mcp.apify.com/actors/[PLACEHOLDER: slug~actor]
```

### Free vs paid tier

Free Apify users are capped at 1 product URL, 1 SERP page, and 3 competitors per product. Paid users get whatever they put in the input.

### Need a custom scraper?

Need different fields, a different site, or a fully managed price-monitoring pipeline? Visit [automationbyexperts](https://scrape.do/?fpr=automationbyexperts).

***

**Keywords:** competitor price tracker, competitor price monitoring, price comparison tool, price intelligence, Amazon price tracker, Walmart price tracker, Target price tracker, Best Buy price tracker, eBay price scraper, Shopify price monitor, MAP monitoring, repricing tool, dropshipping research, market positioning, UPC/EAN/GTIN product matching.

```
PLACEHOLDERS TO FILL:
- API/MCP slug — replace [PLACEHOLDER: slug~actor] with your-username~competitor-price-tracker once published.
```

# Actor input Schema

## `productUrls` (type: `array`):

Reference product URLs to track. Use canonical product pages (e.g. /dp/B0XXXXX), not /offer-listing/ pages. Each URL is processed in parallel.

## `country` (type: `string`):

ISO-3166 country code. Controls Google SERP geo-targeting AND residential proxy country for page fetches.

## `currency` (type: `string`):

ISO-4217 currency code (e.g. USD, EUR, GBP). Competitor prices in any other currency are dropped (not converted) so all reported prices are comparable.

## `maxCompetitors` (type: `integer`):

Stop searching once this many confirmed matches are found per product.

## `maxPages` (type: `integer`):

Number of Google search result pages to scan for each product. Each page yields ~10 candidate URLs.

## `excludedDomains` (type: `array`):

Domains to skip when scanning competitors (in addition to the built-in social/review/hard-blocked list).

## `includedDomains` (type: `array`):

If provided, the Google search query is restricted to these domains via `site:` operators (e.g. amazon.com, walmart.com). Leave empty to search the whole web.

## `model` (type: `string`):

Pick from the curated list (tuned for accuracy-per-dollar on this task). To use any other OpenRouter model, leave this as-is and fill in `customModel` below — it will override this selection.

## `customModel` (type: `string`):

Any OpenRouter-compatible model ID (e.g. `openai/o1-mini`, `x-ai/grok-2`, `cohere/command-r-plus`). If set, this overrides the `AI model` selection above. Browse the full catalog at https://openrouter.ai/models.

## `scrapedoApiKey` (type: `string`):

**Strongly recommended — required if you want most sites (Amazon, eBay, Walmart, Cloudflare-protected stores, etc.) to actually be scraped.** Without this key the actor only uses curl\_cffi + residential proxy, which is blocked by most major retailers and will return empty results for them.

Get a **free** key with 1000 credits/month using my referral link: https://scrape.do/?fpr=automationbyexperts — sign up, copy your token, paste it here.

Domains listed in `src/scrapedo_direct_domains.txt` (Amazon, eBay by default) skip curl\_cffi entirely and go straight through this API to save retry cycles.

## Actor input object example

```json
{
  "productUrls": [
    {
      "url": "https://www.amazon.com/dp/B09B8V1LZ3"
    },
    {
      "url": "https://www.walmart.com/ip/AirPods-Pro-2nd-generation-with-MagSafe-Case-USB-C/5689919121"
    },
    {
      "url": "https://www.target.com/p/airpods-pro-2nd-generation-with-magsafe-case-usb-c/-/A-85978622"
    }
  ],
  "country": "us",
  "currency": "USD",
  "maxCompetitors": 10,
  "maxPages": 2,
  "excludedDomains": [],
  "includedDomains": [],
  "model": "meta-llama/llama-3.1-8b-instruct"
}
```

# Actor output Schema

## `priceIntelligence` (type: `string`):

All competitor matches across all input products. One row per (product, competitor); reference + market aggregate fields repeat per row for filtering/sorting.

# 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 = {
    "productUrls": [
        {
            "url": "https://www.amazon.com/dp/B09B8V1LZ3"
        },
        {
            "url": "https://www.walmart.com/ip/AirPods-Pro-2nd-generation-with-MagSafe-Case-USB-C/5689919121"
        },
        {
            "url": "https://www.target.com/p/airpods-pro-2nd-generation-with-magsafe-case-usb-c/-/A-85978622"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fayoussef/competitor-price-tracker-monitor").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 = { "productUrls": [
        { "url": "https://www.amazon.com/dp/B09B8V1LZ3" },
        { "url": "https://www.walmart.com/ip/AirPods-Pro-2nd-generation-with-MagSafe-Case-USB-C/5689919121" },
        { "url": "https://www.target.com/p/airpods-pro-2nd-generation-with-magsafe-case-usb-c/-/A-85978622" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fayoussef/competitor-price-tracker-monitor").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 '{
  "productUrls": [
    {
      "url": "https://www.amazon.com/dp/B09B8V1LZ3"
    },
    {
      "url": "https://www.walmart.com/ip/AirPods-Pro-2nd-generation-with-MagSafe-Case-USB-C/5689919121"
    },
    {
      "url": "https://www.target.com/p/airpods-pro-2nd-generation-with-magsafe-case-usb-c/-/A-85978622"
    }
  ]
}' |
apify call fayoussef/competitor-price-tracker-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fayoussef/competitor-price-tracker-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Competitor Price Tracker & Monitor",
        "description": "Paste any product URL and instantly find top store selling the same item. PriceRadar returns each competitor's price, your market rank, gap vs. cheapest, gap vs. average, and a suggested pricing action. Works on Amazon, eBay, Walmart, Shopify & more. Export to CSV, Excel, JSON, or API.",
        "version": "0.0",
        "x-build-id": "06wqq52ihae4DyB2C"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fayoussef~competitor-price-tracker-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fayoussef-competitor-price-tracker-monitor",
                "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/fayoussef~competitor-price-tracker-monitor/runs": {
            "post": {
                "operationId": "runs-sync-fayoussef-competitor-price-tracker-monitor",
                "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/fayoussef~competitor-price-tracker-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-fayoussef-competitor-price-tracker-monitor",
                "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": [
                    "productUrls"
                ],
                "properties": {
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Reference product URLs to track. Use canonical product pages (e.g. /dp/B0XXXXX), not /offer-listing/ pages. Each URL is processed in parallel.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "us",
                            "gb",
                            "ca",
                            "au",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "se",
                            "pl",
                            "ae",
                            "sa",
                            "za",
                            "br",
                            "mx",
                            "in",
                            "jp",
                            "sg"
                        ],
                        "type": "string",
                        "description": "ISO-3166 country code. Controls Google SERP geo-targeting AND residential proxy country for page fetches.",
                        "default": "us"
                    },
                    "currency": {
                        "title": "Target Currency",
                        "type": "string",
                        "description": "ISO-4217 currency code (e.g. USD, EUR, GBP). Competitor prices in any other currency are dropped (not converted) so all reported prices are comparable.",
                        "default": "USD"
                    },
                    "maxCompetitors": {
                        "title": "Max competitors per product",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Stop searching once this many confirmed matches are found per product.",
                        "default": 10
                    },
                    "maxPages": {
                        "title": "Google SERP pages per product",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of Google search result pages to scan for each product. Each page yields ~10 candidate URLs.",
                        "default": 2
                    },
                    "excludedDomains": {
                        "title": "Additional excluded domains",
                        "type": "array",
                        "description": "Domains to skip when scanning competitors (in addition to the built-in social/review/hard-blocked list).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "includedDomains": {
                        "title": "Additional included domains",
                        "type": "array",
                        "description": "If provided, the Google search query is restricted to these domains via `site:` operators (e.g. amazon.com, walmart.com). Leave empty to search the whole web.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "model": {
                        "title": "AI model",
                        "enum": [
                            "meta-llama/llama-3.1-8b-instruct",
                            "openai/gpt-4o-mini",
                            "openai/gpt-5",
                            "openai/gpt-5-mini",
                            "google/gemini-2.5-flash"
                        ],
                        "type": "string",
                        "description": "Pick from the curated list (tuned for accuracy-per-dollar on this task). To use any other OpenRouter model, leave this as-is and fill in `customModel` below — it will override this selection.",
                        "default": "meta-llama/llama-3.1-8b-instruct"
                    },
                    "customModel": {
                        "title": "Custom model (optional — overrides the dropdown)",
                        "type": "string",
                        "description": "Any OpenRouter-compatible model ID (e.g. `openai/o1-mini`, `x-ai/grok-2`, `cohere/command-r-plus`). If set, this overrides the `AI model` selection above. Browse the full catalog at https://openrouter.ai/models."
                    },
                    "scrapedoApiKey": {
                        "title": "Scraper API Key (required for reliable scraping of most sites)",
                        "type": "string",
                        "description": "**Strongly recommended — required if you want most sites (Amazon, eBay, Walmart, Cloudflare-protected stores, etc.) to actually be scraped.** Without this key the actor only uses curl_cffi + residential proxy, which is blocked by most major retailers and will return empty results for them.\n\nGet a **free** key with 1000 credits/month using my referral link: https://scrape.do/?fpr=automationbyexperts — sign up, copy your token, paste it here.\n\nDomains listed in `src/scrapedo_direct_domains.txt` (Amazon, eBay by default) skip curl_cffi entirely and go straight through this API to save retry cycles."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```