# eBay Sold Listings Scraper (`parsebird/ebay-sold-listings-scraper`) Actor
Scrape eBay sold listings with real transaction prices across 8 marketplaces. Filter by keyword, category, price, condition, date range, and sort order. Returns 22+ fields per item including sold price, shipping, seller info, and listing type.
- **URL**: https://apify.com/parsebird/ebay-sold-listings-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:** E-commerce, Automation, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet
## Pricing
from $2.40 / 1,000 ebay sold listings
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
### eBay Sold Listings Scraper
Extract real eBay sold prices — actual completed transactions, not asking prices or active listings.
Search by keyword across 8 eBay marketplaces, filter by category, price range, condition, date, and sort order — get 22+ structured data fields per sold listing including final price, shipping, seller info, and listing type.
##### Copy to your AI assistant
Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.
````
Actor: parsebird/ebay-sold-listings-scraper — Scrape eBay sold listings with real transaction prices across 8 marketplaces.
Usage: from apify\_client import ApifyClient; client = ApifyClient("YOUR\_TOKEN"); run = client.actor("parsebird/ebay-sold-listings-scraper").call(run\_input={"keywords": \["iphone 15 pro"], "count": 100, "daysToScrape": 30, "ebaySite": "ebay.com"})
Inputs: keywords (string\[], 1-6 terms, required), daysToScrape (int, 1-90, default 30), count (int, max per keyword, default 100), categoryId (string, "0"=all), subcategoryId (string, overrides category), ebaySite (string: ebay.com|co.uk|de|fr|it|es|ca|com.au), sortOrder (string: endedRecently|timeNewlyListed|pricePlusPostageLowest|pricePlusPostageHighest|distanceNearest), minPrice/maxPrice (number), itemLocation (default|domestic|worldwide), itemCondition (any|new|used)
Output fields: itemId, url, title, condition, conditionId, categoryId, category, endedAt, soldPrice, soldCurrency, listingType, isBestOfferAccepted, shippingPrice, shippingCurrency, shippingType, totalPrice, thumbnailUrl, sellerUsername, sellerPositivePercent, sellerFeedbackScore, sellerType, scrapedAt, keyword
API spec: https://apify.com/parsebird/ebay-sold-listings-scraper/api
Get token: https://console.apify.com/account/integrations
````
### What is eBay Sold Listings Scraper?
**eBay Sold Listings Scraper** extracts confirmed sold item data from [eBay](https://www.ebay.com) — real completed sales with final transaction prices. Unlike active listing scrapers, this actor returns only items that actually sold, making it ideal for **price analysis, market research, and resale pricing intelligence**.
This actor works as an **eBay sold items API alternative** — no official API access required. It supports all major eBay marketplaces: US, UK, Germany, France, Italy, Spain, Canada, and Australia.
Key capabilities:
- 🔍 Multi-keyword search (up to 6 keywords per run)
- 🌍 8 eBay marketplaces with localized condition labels
- 📊 22+ data fields per listing including seller metrics
- 📅 Date range filtering (1–90 days back)
- 💰 Price range, condition, and category filters
- 🏷️ Listing type detection (auction, Buy It Now, Best Offer)
- 📦 Shipping cost and type extraction
### What data can you extract from eBay sold listings?
| Field | Description |
|-------|-------------|
| `itemId` | eBay item ID |
| `url` | Full listing URL |
| `title` | Listing title |
| `condition` | Localized condition label (e.g. "Pre-Owned", "Gebraucht", "Neuf") |
| `conditionId` | Numeric eBay condition ID (1000=New, 3000=Used, etc.) |
| `categoryId` | Category ID used for the search |
| `category` | Category label from the search page |
| `endedAt` | Sale completion timestamp (ISO 8601) |
| `soldPrice` | Final transaction price |
| `soldCurrency` | Currency code (USD, GBP, EUR, CAD, AUD) |
| `listingType` | How it sold: "auction", "buy_it_now", "best_offer_accepted" |
| `isBestOfferAccepted` | Whether the sale was via accepted Best Offer |
| `shippingPrice` | Shipping cost |
| `shippingCurrency` | Shipping currency |
| `shippingType` | "free", "paid", "pickup", or "unknown" |
| `totalPrice` | soldPrice + shippingPrice (when currencies match) |
| `thumbnailUrl` | 500px product image from i.ebayimg.com |
| `sellerUsername` | Seller username |
| `sellerPositivePercent` | Positive feedback percentage |
| `sellerFeedbackScore` | Total feedback count |
| `sellerType` | "private" or "business" (EU sites only) |
| `scrapedAt` | Scrape timestamp (ISO 8601) |
| `keyword` | Which search keyword produced this result |
### How to scrape eBay sold listings
1. Go to [eBay Sold Listings Scraper](https://apify.com/parsebird/ebay-sold-listings-scraper) on Apify Store
2. Click **Try for free** to open the input form
3. Enter one or more keywords (e.g. "rtx 4080", "iphone 15 pro")
4. Set your filters: days back, max results, category, price range, condition
5. Choose your eBay marketplace (US, UK, DE, FR, IT, ES, CA, AU)
6. Click **Start** and wait for results
7. Download your data as JSON, CSV, or Excel — or access via API
### Input parameters
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| keywords | string[] | **Yes** | — | 1–6 search terms. Each runs as a separate search. |
| daysToScrape | integer | No | 30 | Days back to include (1–90) |
| count | integer | No | 100 | Max results per keyword |
| categoryId | string | No | "0" | Main eBay category (0 = All Categories) |
| subcategoryId | string | No | "" | Subcategory ID (overrides categoryId) |
| ebaySite | string | No | "ebay.com" | eBay marketplace to search |
| sortOrder | string | No | "endedRecently" | Sort: endedRecently, timeNewlyListed, pricePlusPostageLowest, pricePlusPostageHighest |
| minPrice | number | No | — | Minimum sold price filter |
| maxPrice | number | No | — | Maximum sold price filter |
| itemLocation | string | No | "default" | default, domestic, worldwide |
| itemCondition | string | No | "any" | any, new, used |
| proxyConfiguration | object | No | Datacenter | Proxy settings for reliable runs |
Backward compatibility: the deprecated `keyword` (string) and `search` (string) fields are still accepted for existing integrations.
### Output example
```json
{
"itemId": "178234355418",
"url": "https://www.ebay.com/itm/178234355418",
"title": "iPhone 15 Pro Max - 512 GB - Blue - Unlocked - 99% Batt Health",
"condition": "Pre-Owned",
"conditionId": 3000,
"categoryId": "0",
"category": "All Categories",
"endedAt": "2026-06-20T05:00:00.000Z",
"soldPrice": "750",
"soldCurrency": "USD",
"listingType": "best_offer_accepted",
"isBestOfferAccepted": true,
"shippingPrice": null,
"shippingCurrency": null,
"shippingType": "unknown",
"totalPrice": "750",
"thumbnailUrl": "https://i.ebayimg.com/images/g/V7wAAeSw9XlqNEn6/s-l500.webp",
"sellerUsername": "akagi7",
"sellerPositivePercent": 100.0,
"sellerFeedbackScore": 51,
"sellerType": null,
"scrapedAt": "2026-06-20T15:18:46.000Z",
"keyword": "iphone 15 pro"
}
````
### Use cases
- 📈 **Price research** — Find actual market prices for electronics, collectibles, or any product category
- 💹 **Resale arbitrage** — Compare buy prices vs. sold prices to identify profitable flips
- 📊 **Market trend analysis** — Track how prices change over time for specific products
- 🏷️ **Competitive pricing** — Set optimal listing prices based on real transaction data
- 🤖 **Pricing APIs** — Feed sold price data into automated pricing engines or dashboards
- 📋 **Insurance valuations** — Document fair market value with real sales evidence
- 🔬 **Academic research** — Study secondary market dynamics and consumer behavior
### How much does it cost to scrape eBay sold listings?
| Tier | Price per result | Price per 1,000 results |
|------|-----------------|------------------------|
| Free, Bronze, Silver | $0.0034 | **$3.40** |
| Gold | $0.0024 | **$2.40** |
Each sold listing pushed to the dataset counts as one billable event. A typical run of 100 results costs approximately $0.34 (Free/Bronze/Silver tier). The [free trial](https://apify.com/pricing) includes enough credits to test the actor.
Platform compute costs are included in the per-event price — you only pay for results.
### Integrations and API access
eBay Sold Listings Scraper runs on the [Apify platform](https://apify.com), giving you:
- **Scheduling** — Run daily, weekly, or at any custom interval
- **API access** — Start runs and fetch results programmatically
- **Webhooks** — Get notified when a run completes
- **Integrations** — Connect to Google Sheets, Slack, Zapier, Make, and [more](https://docs.apify.com/platform/integrations)
- **Export formats** — Download as JSON, CSV, Excel, or XML
#### Python example
```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("parsebird/ebay-sold-listings-scraper").call(run_input={
"keywords": ["rtx 4080", "rtx 4090"],
"count": 200,
"daysToScrape": 30,
"ebaySite": "ebay.com",
"categoryId": "58058",
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(f"{item['title']} — {item['soldCurrency']} {item['soldPrice']}")
```
#### JavaScript example
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor("parsebird/ebay-sold-listings-scraper").call({
keywords: ["rtx 4080", "rtx 4090"],
count: 200,
daysToScrape: 30,
ebaySite: "ebay.com",
categoryId: "58058",
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => console.log(`${item.title} — ${item.soldCurrency} ${item.soldPrice}`));
```
### Is it legal to scrape eBay?
Web scraping of publicly available data is generally legal, as established by the US Ninth Circuit Court ruling in *hiQ Labs v. LinkedIn* (2022). The eBay Sold Listings Scraper collects only publicly visible information from eBay's search results pages — data that any visitor can see without logging in.
This actor does not bypass any authentication, access private user data, or violate eBay's technical protections. Users are responsible for ensuring their use case complies with applicable laws and [eBay's terms of service](https://www.ebay.com/help/policies/member-behaviour-policies/user-agreement?id=4259).
For more on web scraping legality, see [Apify's guide to web scraping and the law](https://blog.apify.com/is-web-scraping-legal/).
### Related actors
- [Craigslist Scraper](https://apify.com/parsebird/craigslist-scraper) — Extract listings from Craigslist across 50+ cities
- [Data Deduplicator](https://apify.com/parsebird/dataset-deduplicator) — Remove duplicate records from any Apify dataset
- [Data Cleaner](https://apify.com/parsebird/data-cleaner) — Clean, filter, and transform dataset records
### FAQ
**What's the difference between sold price and asking price?**
This actor returns only *confirmed sales* — items where a buyer actually completed the purchase. When `isBestOfferAccepted` is true, the `soldPrice` field shows the seller's asking price (not the accepted offer amount, which eBay doesn't disclose).
**Which eBay sites are supported?**
Eight marketplaces: ebay.com (US), ebay.co.uk (UK), ebay.de (Germany), ebay.fr (France), ebay.it (Italy), ebay.es (Spain), ebay.ca (Canada), and ebay.com.au (Australia). Each returns prices in the local currency.
**Can I schedule recurring runs?**
Yes. Use [Apify's scheduling feature](https://docs.apify.com/platform/schedules) to run this actor daily, weekly, or at any custom interval. Combine with webhooks to automatically process new data.
**How do I filter by subcategory?**
Set the `subcategoryId` field to an eBay category ID number. When set, it overrides `categoryId`. You can find category IDs by browsing eBay's category tree or using [this reference](https://sold-comps.com/ebay-categories).
**What does the `listingType` field tell me?**
It indicates how the item sold: "auction" (bidding), "buy\_it\_now" (fixed price), or "best\_offer\_accepted" (negotiated price). This helps distinguish market-driven prices from fixed-price sales.
**Why are some fields null?**
Fields like `shippingPrice`, `sellerType`, and `conditionId` can be null when eBay doesn't display that information on the search card. `sellerType` is only available on EU sites (Germany, France, Italy, Spain). The `condition` field is always the authoritative source — `conditionId` is a best-effort lookup.
# Actor input Schema
## `keywords` (type: `array`):
1–6 search terms. Each keyword runs as a separate search with the same filters applied. Results are tagged with the keyword for easy filtering.
## `daysToScrape` (type: `integer`):
Number of days back to include sold listings (1–90). Listings older than this are excluded from results.
## `count` (type: `integer`):
Maximum number of sold listings to return per keyword. Lower values produce faster, cheaper runs.
## `categoryId` (type: `string`):
eBay main category filter. Use 'All Categories' for the broadest search.
## `subcategoryId` (type: `string`):
Optional subcategory ID. When set, overrides the Category field (maps to \_sacat). Find IDs at https://sold-comps.com/ebay-categories
## `ebaySite` (type: `string`):
eBay marketplace to search. Each site has its own listings, currency, and language.
## `sortOrder` (type: `string`):
How to sort sold search results.
## `minPrice` (type: `number`):
Minimum sold price filter. Leave empty for no minimum.
## `maxPrice` (type: `number`):
Maximum sold price filter. Leave empty for no maximum.
## `itemLocation` (type: `string`):
Filter by where the item is located.
## `itemCondition` (type: `string`):
Filter by item condition.
## `keyword` (type: `string`):
Single search keyword. Deprecated: use the 'keywords' array field instead. Accepted for backward compatibility.
## `search` (type: `string`):
Deprecated alias for 'keyword'. Use the 'keywords' array instead. Backslash-escaped quotes in the value are unescaped before the search runs.
## `proxyConfiguration` (type: `object`):
Datacenter proxies work for most runs. Switch to residential if you see blocks or empty results.
## Actor input object example
```json
{
"keywords": [
"iphone 15 pro"
],
"daysToScrape": 30,
"count": 50,
"categoryId": "0",
"subcategoryId": "",
"ebaySite": "ebay.com",
"sortOrder": "endedRecently",
"itemLocation": "default",
"itemCondition": "any",
"proxyConfiguration": {
"useApifyProxy": true
}
}
```
# Actor output Schema
## `dataset` (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 = {
"keywords": [
"iphone 15 pro"
],
"daysToScrape": 30,
"count": 50,
"categoryId": "0",
"ebaySite": "ebay.com",
"sortOrder": "endedRecently",
"proxyConfiguration": {
"useApifyProxy": true
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/ebay-sold-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"keywords": ["iphone 15 pro"],
"daysToScrape": 30,
"count": 50,
"categoryId": "0",
"ebaySite": "ebay.com",
"sortOrder": "endedRecently",
"proxyConfiguration": { "useApifyProxy": True },
}
# Run the Actor and wait for it to finish
run = client.actor("parsebird/ebay-sold-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 '{
"keywords": [
"iphone 15 pro"
],
"daysToScrape": 30,
"count": 50,
"categoryId": "0",
"ebaySite": "ebay.com",
"sortOrder": "endedRecently",
"proxyConfiguration": {
"useApifyProxy": true
}
}' |
apify call parsebird/ebay-sold-listings-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=parsebird/ebay-sold-listings-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "eBay Sold Listings Scraper",
"description": "Scrape eBay sold listings with real transaction prices across 8 marketplaces. Filter by keyword, category, price, condition, date range, and sort order. Returns 22+ fields per item including sold price, shipping, seller info, and listing type.",
"version": "1.1",
"x-build-id": "Bphah3TQn9PJ3M141"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/parsebird~ebay-sold-listings-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-parsebird-ebay-sold-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/parsebird~ebay-sold-listings-scraper/runs": {
"post": {
"operationId": "runs-sync-parsebird-ebay-sold-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/parsebird~ebay-sold-listings-scraper/run-sync": {
"post": {
"operationId": "run-sync-parsebird-ebay-sold-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": {
"keywords": {
"title": "Keywords",
"minItems": 1,
"maxItems": 6,
"uniqueItems": true,
"type": "array",
"description": "1–6 search terms. Each keyword runs as a separate search with the same filters applied. Results are tagged with the keyword for easy filtering.",
"items": {
"type": "string"
}
},
"daysToScrape": {
"title": "Days to Scrape",
"minimum": 1,
"maximum": 90,
"type": "integer",
"description": "Number of days back to include sold listings (1–90). Listings older than this are excluded from results.",
"default": 30
},
"count": {
"title": "Max Results per Keyword",
"minimum": 1,
"type": "integer",
"description": "Maximum number of sold listings to return per keyword. Lower values produce faster, cheaper runs.",
"default": 100
},
"categoryId": {
"title": "Category",
"enum": [
"0",
"550",
"2984",
"267",
"12576",
"625",
"15032",
"11450",
"11116",
"1",
"58058",
"293",
"14339",
"237",
"45100",
"99",
"172008",
"26395",
"11700",
"281",
"11232",
"11233",
"619",
"1281",
"870",
"10542",
"316",
"888",
"64482",
"260",
"1305",
"220",
"3252",
"1249",
"20081"
],
"type": "string",
"description": "eBay main category filter. Use 'All Categories' for the broadest search.",
"default": "0"
},
"subcategoryId": {
"title": "Subcategory",
"type": "string",
"description": "Optional subcategory ID. When set, overrides the Category field (maps to _sacat). Find IDs at https://sold-comps.com/ebay-categories",
"default": ""
},
"ebaySite": {
"title": "eBay Site",
"enum": [
"ebay.com",
"ebay.co.uk",
"ebay.de",
"ebay.fr",
"ebay.it",
"ebay.es",
"ebay.ca",
"ebay.com.au"
],
"type": "string",
"description": "eBay marketplace to search. Each site has its own listings, currency, and language.",
"default": "ebay.com"
},
"sortOrder": {
"title": "Sort Order",
"enum": [
"endedRecently",
"timeNewlyListed",
"pricePlusPostageLowest",
"pricePlusPostageHighest",
"distanceNearest"
],
"type": "string",
"description": "How to sort sold search results.",
"default": "endedRecently"
},
"minPrice": {
"title": "Min Price",
"minimum": 0,
"type": "number",
"description": "Minimum sold price filter. Leave empty for no minimum."
},
"maxPrice": {
"title": "Max Price",
"minimum": 0,
"type": "number",
"description": "Maximum sold price filter. Leave empty for no maximum."
},
"itemLocation": {
"title": "Item Location",
"enum": [
"default",
"domestic",
"worldwide"
],
"type": "string",
"description": "Filter by where the item is located.",
"default": "default"
},
"itemCondition": {
"title": "Condition",
"enum": [
"any",
"new",
"used"
],
"type": "string",
"description": "Filter by item condition.",
"default": "any"
},
"keyword": {
"title": "Keyword (deprecated — use Keywords)",
"type": "string",
"description": "Single search keyword. Deprecated: use the 'keywords' array field instead. Accepted for backward compatibility."
},
"search": {
"title": "Search (deprecated — use Keywords)",
"type": "string",
"description": "Deprecated alias for 'keyword'. Use the 'keywords' array instead. Backslash-escaped quotes in the value are unescaped before the search runs."
},
"proxyConfiguration": {
"title": "Proxy Configuration",
"type": "object",
"description": "Datacenter proxies work for most runs. Switch to residential if you see blocks or empty results.",
"default": {
"useApifyProxy": 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
}
}
}
}
}
}
}
}
}
}
```