# eBay Listings Scraper – Prices & Auctions (`astravalabs/ebay-listings-scraper`) Actor

eBay listings scraper for price monitoring and market research across 13 marketplaces. Extract up to 60 fields, including prices, shipping, sellers, bids, watchers, sold counts, promotions, and sponsored results. Not affiliated with eBay Inc.

- **URL**: https://apify.com/astravalabs/ebay-listings-scraper.md
- **Developed by:** [astravalabs](https://apify.com/astravalabs) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## eBay Listings Scraper

Turn live eBay search results into structured data for pricing, demand, seller,
auction, and cross-marketplace analysis.

> **Unofficial tool:** This Actor is independently developed and is not
> affiliated with, endorsed by, or sponsored by eBay Inc. eBay names and
> trademarks belong to their respective owners.

Enter up to 50 product searches, choose one of 13 localized eBay marketplaces,
and apply the same filters a shopper would use on eBay. The Actor returns one
dataset row per active listing, including the displayed price, shipping,
condition, seller feedback, watchers, quantity sold, bids, time left,
promotions, and sponsored status when eBay shows them.

### Why use this Actor?

- **Research a market, not just one product.** Each search page requests up to
  240 listings. A run can process 50 queries and up to 10 pages per query.
- **Measure supply and visible demand together.** Compare price and shipping
  with `watchCount`, `quantitySold`, bids, seller reputation, and sponsored
  placement.
- **Get localized data from 13 eBay sites.** Currency, prices, shipping text,
  conditions, seller types, activity counts, and badges are parsed for the
  selected marketplace.
- **Filter at the source.** Price, condition, location, buying format, and sort
  order are sent to eBay rather than applied after collection.
- **Keep both clean values and source text.** Numeric fields are ready for
  analysis, while fields such as `displayedPriceText`, `shippingText`, and
  `subtitleText` preserve what eBay displayed.
- **Run production workflows with confidence.** Results are deduplicated by
  marketplace and item ID. Retryable blocks and network failures trigger a new
  proxy session, and every run includes a detailed `RUN_REPORT`.

This Actor is a strong fit for broad and recurring market scans where coverage
matters most.

### Why choose this Actor?

| Need | What this Actor provides |
| --- | --- |
| Broad search coverage | Up to 240 listings per requested search page, 50 queries per run, and 13 localized marketplaces |
| Market and demand signals | Prices, shipping, watchers, quantity sold, bids, seller reputation, promotions, and sponsored placement |
| Analysis-ready values | Normalized numeric and boolean fields alongside the original text displayed by eBay |
| Reliable recurring runs | Marketplace-aware proxy sessions, retries, deduplication, progress checkpoints, and a detailed run report |
| Transparent scope | Fast search-result collection without pretending to provide detail-page descriptions, specifications, or full galleries |

### Who is it for?

- **eBay sellers and resellers** comparing active competition before sourcing,
  pricing, or relisting inventory.
- **Pricing and e-commerce teams** monitoring price bands, delivery costs,
  promotions, and seller positioning.
- **Market researchers** measuring listing supply, visible demand signals, and
  marketplace differences.
- **Auction buyers and collectors** finding newly listed or ending-soon auctions
  with bid counts and time remaining.
- **Brands and agencies** tracking sponsored visibility, direct-from-brand
  badges, seller quality, and product positioning.
- **Developers and data teams** building scheduled datasets, dashboards, alerts,
  and catalog-discovery pipelines through Apify.

### Common use cases

#### Competitive price monitoring

Schedule the same searches and compare `displayedPrice`,
`displayedTotalPrice`, `shippingPrice`, `conditionGroup`, and
`sellerFeedbackPercentage` between runs.

#### Product and niche research

Use `quantitySold` and `watchCount` alongside the number of active listings to
identify products with visible interest and assess how crowded a niche is.

#### Auction tracking

Filter to `AUCTION`, sort by `TIME_ENDING_SOONEST`, and use `bidCount` and
`timeLeftText` to feed alerts or watchlists.

#### Cross-border market analysis

Run the same queries separately for different marketplaces and compare local
currency, shipping, domestic availability, seller type, and pricing.

#### Organic versus sponsored visibility

Use `sponsored`, `position`, `query`, and seller fields to separate promoted
listings from organic search results.

### Quick start

Paste this input into the Apify Console:

```json
{
  "queries": [
    "iphone 15 pro",
    "samsung galaxy s24"
  ],
  "marketplace": "US",
  "maxResultsPerQuery": 100,
  "sortOrder": "BEST_MATCH",
  "minPrice": 200,
  "maxPrice": 1200,
  "itemLocation": "DOMESTIC",
  "condition": "USED",
  "buyingFormat": "ACCEPTS_OFFERS",
  "maxPagesPerQuery": 5,
  "maxTotalResults": 1000
}
````

The Actor streams listings to the default dataset. You can inspect them in the
table view, download JSON, CSV, Excel, or XML, or retrieve them through the
Apify API.

### Example inputs

#### Find ending auctions

```json
{
  "queries": [
    "charizard pokemon card",
    "vintage omega watch"
  ],
  "marketplace": "US",
  "buyingFormat": "AUCTION",
  "sortOrder": "TIME_ENDING_SOONEST",
  "maxResultsPerQuery": 240,
  "maxPagesPerQuery": 1
}
```

#### Monitor newly listed domestic inventory

```json
{
  "queries": [
    "gaming laptop",
    "rtx 5080"
  ],
  "marketplace": "DE",
  "condition": "USED",
  "itemLocation": "DOMESTIC",
  "sortOrder": "TIME_NEWLY_LISTED",
  "maxResultsPerQuery": 480,
  "maxPagesPerQuery": 2
}
```

#### Build a Buy It Now price dataset

```json
{
  "queries": [
    "air jordan retro"
  ],
  "marketplace": "UK",
  "condition": "NEW",
  "buyingFormat": "BUY_IT_NOW",
  "minPrice": 100,
  "maxPrice": 500,
  "sortOrder": "PRICE_LOW_TO_HIGH"
}
```

### Supported marketplaces

| Input | eBay site | Market | Currency |
| --- | --- | --- | --- |
| `US` | ebay.com | United States | USD |
| `UK` | ebay.co.uk | United Kingdom | GBP |
| `DE` | ebay.de | Germany | EUR |
| `AU` | ebay.com.au | Australia | AUD |
| `CA` | ebay.ca | Canada | CAD |
| `FR` | ebay.fr | France | EUR |
| `IT` | ebay.it | Italy | EUR |
| `ES` | ebay.es | Spain | EUR |
| `NL` | ebay.nl | Netherlands | EUR |
| `IE` | ebay.ie | Ireland | EUR |
| `AT` | ebay.at | Austria | EUR |
| `CH` | ebay.ch | Switzerland | CHF |
| `PL` | ebay.pl | Poland | PLN |

Choose one marketplace per run. To compare markets, run the same input once for
each marketplace.

### Input schema

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `queries` | string array | required | 1–50 keyword searches. Empty and duplicate values are removed. |
| `marketplace` | string | `US` | One of the 13 marketplace codes above. |
| `maxResultsPerQuery` | integer | `100` | Maximum unique listings saved per query. `0` removes this user cap within the hard safety limits. |
| `sortOrder` | string | `BEST_MATCH` | eBay sort order to apply. |
| `minPrice` | number | none | Minimum displayed price in the selected marketplace's currency. |
| `maxPrice` | number | none | Maximum displayed price in the selected marketplace's currency. |
| `itemLocation` | string | `DEFAULT` | `DEFAULT`, `DOMESTIC`, or `WORLDWIDE`. |
| `condition` | string | `ANY` | Condition group sent to eBay. |
| `buyingFormat` | string | `ANY` | Listing format sent to eBay. |
| `maxPagesPerQuery` | integer | `5` | Request-effort limit per query, from 1 to 10 pages. |
| `maxTotalResults` | integer | `1000` | Whole-run result cap. `0` removes this user cap within the hard safety limit. |

#### Sort orders

- `BEST_MATCH`
- `TIME_ENDING_SOONEST`
- `TIME_NEWLY_LISTED`
- `PRICE_LOW_TO_HIGH`
- `PRICE_HIGH_TO_LOW`
- `DISTANCE_NEAREST_FIRST`

#### Conditions

- `ANY`
- `NEW`
- `OPEN_BOX`
- `REFURBISHED`
- `USED`
- `FOR_PARTS`

`REFURBISHED` includes eBay's Certified, Excellent, Very Good, and Good
refurbished grades. The dataset keeps eBay's localized label in `condition` and
also returns the normalized group in `conditionGroup`.

#### Buying formats

- `ANY`
- `AUCTION`
- `BUY_IT_NOW`
- `ACCEPTS_OFFERS`

`ANY` does not send a buying-format filter to eBay.

### Output example

The following example is shortened for readability. A dataset item contains up
to 60 fields:

```json
{
  "query": "iphone 15 pro",
  "marketplace": "US",
  "position": 2,
  "itemId": "168537709082",
  "categoryId": "9355",
  "epid": "8062766781",
  "title": "Apple iPhone 15 128GB Black 48MP Camera iOS Bar Style",
  "url": "https://www.ebay.com/itm/168537709082",
  "imageUrl": "https://i.ebayimg.com/images/g/example/s-l500.webp",
  "condition": "Pre-Owned",
  "conditionGroup": "USED",
  "sellerType": null,
  "listingType": "FIXED_PRICE",
  "quantitySold": null,
  "watchCount": 90,
  "sponsored": true,
  "displayedPrice": 270.0,
  "displayedPriceText": "$270.00",
  "currency": "USD",
  "shippingPrice": 0.0,
  "shippingType": "PICKUP",
  "displayedTotalPrice": 270.0,
  "bestOfferAvailable": true,
  "itemLocation": "United States",
  "productRating": 5.0,
  "productRatingCount": 49,
  "sellerUsername": "example-seller",
  "sellerFeedbackScore": 1200,
  "sellerFeedbackPercentage": 99.8,
  "freeReturns": false,
  "badges": [],
  "collectedAt": "2026-07-25T16:08:57.024989+00:00"
}
```

### Output schema

Fields are grouped below by purpose. Values that are not displayed on an eBay
search card are returned as `null`, `false`, or an empty list as appropriate.

| Group | Fields |
| --- | --- |
| Search context | `query`, `marketplace`, `position`, `collectedAt` |
| Listing identity | `itemId`, `categoryId`, `variantId`, `epid`, `title`, `subtitleText`, `itemAttributes`, `url`, `imageUrl`, `hasGallery` |
| Price | `displayedPrice`, `displayedPriceText`, `priceIsRange`, `priceRangeMin`, `priceRangeMax`, `originalPrice`, `couponPrice`, `dealLabel`, `currency`, `unitPrice`, `unitPriceText` |
| Shipping | `shippingPrice`, `shippingType`, `shippingText`, `deliveryEstimate`, `pickupAvailable`, `displayedTotalPrice`, `itemLocation` |
| Listing and demand | `condition`, `conditionGroup`, `listingType`, `bidCount`, `timeLeftText`, `bestOfferAvailable`, `quantitySold`, `watchCount`, `sponsored`, `newListing`, `scarcityMessage` |
| Seller | `sellerUsername`, `sellerType`, `sellerFeedbackScore`, `sellerFeedbackPercentage`, `topRatedSeller`, `ebayTopService`, `directFromBrand` |
| Product and promotion | `productRating`, `productRatingCount`, `authenticityGuarantee`, `freeReturns`, `promotionTexts`, `badges` |

The dataset table view selects 56 fields for convenient browsing. Raw dataset
records also include the combined `bestOffer` flag and the price-related source
text fields `originalPriceText`, `couponPriceText`, and `couponText`.

#### Important field notes

- `displayedPrice` is the current value shown on the active search card. It is
  not a completed-sale price.
- `displayedTotalPrice` is calculated only when both the displayed price and a
  numeric shipping price are available.
- `priceIsRange`, `priceRangeMin`, and `priceRangeMax` distinguish variation
  price ranges from a single price.
- `quantitySold`, `watchCount`, seller fields, ratings, delivery estimates, and
  badges are populated only when eBay displays them in search results. A
  missing value is not converted to zero.
- `sponsored` identifies promoted search cards so you can include or exclude
  paid placement in downstream analysis.
- `hasGallery` indicates that eBay shows an interactive gallery on the search
  card; the Actor returns the card's primary image rather than visiting the
  detail page for a full gallery.

### Run report

In addition to the dataset, every run stores a `RUN_REPORT` record in the
default key-value store. It provides whole-run and per-query diagnostics:

```json
{
  "summary": {
    "persisted": 960,
    "duplicates": 0,
    "marketplace": "US",
    "queries": 2,
    "successful_pages": 4,
    "request_retries": 1,
    "recovered_pages": 1,
    "page_success_rate": 1.0,
    "duration_seconds": 18.42,
    "blocked_run": false
  },
  "queries": [
    {
      "query": "iphone 15 pro",
      "status": "completed",
      "pages_completed": 2,
      "listings_persisted": 480,
      "duplicates": 0
    }
  ]
}
```

Use the report to distinguish a genuinely empty search from an interrupted or
blocked request, audit retry recovery, and monitor result caps, bandwidth, and
per-query completion.

While the Actor is running, it also updates a `RUN_PROGRESS` record every 30
seconds. This checkpoint remains available if a hard timeout prevents the
final `RUN_REPORT` from being written. It includes completed query names, the
next page for every unfinished query, persisted and detected counts, retry
statistics, and references to exact deduplication-key shards stored as
`RUN_PROGRESS_DEDUP_####`.

### Scale and limits

- Up to 50 unique queries per run
- Up to 10 pages per query
- Up to 2,400 unique results per query
- Up to 120,000 results per run
- Up to 16 queries processed concurrently
- Up to 2 page requests per active query, with a global maximum of 32

The first-run defaults are intentionally small: 100 results per query and
1,000 results across the run, with a request-effort cap of 5 pages per query.
Raising a result limit does not raise the page limit automatically. For larger
market studies, split work by marketplace, category, price band, or keyword
batch and schedule the runs separately.

### What this Actor does not collect

The Actor does not open individual listing pages. It therefore does not return
full descriptions, complete item-specific dictionaries, return policies, or a
full image gallery. Choose this Actor when you need broad active-search
coverage, repeatable filters, and market-level signals. Use a detail-page
scraper when you need deep enrichment for a small set of item URLs.

### FAQ

#### Why are some fields missing or `null`?

The Actor returns data displayed on eBay search-result cards. Fields such as
watchers, quantity sold, seller feedback, delivery estimates, ratings, and
promotions are populated only when eBay displays them for that listing. A
missing value is kept as `null` rather than converted to zero.

#### Are these active prices or sold prices?

`displayedPrice` is the current asking price shown on an active search result.
It is not a completed-sale price. Use a sold-listings scraper when you need
completed listings, sold dates, or historical price comparisons.

#### What happens if eBay blocks a request?

Temporary network errors, rate limits, login redirects, challenges, and access
denials trigger retries with fresh proxy sessions. If recovery is unsuccessful,
the Actor records the affected query and terminal outcome in `RUN_REPORT`. A
run in which every query is blocked fails explicitly instead of returning a
misleading successful empty dataset.

#### How many listings can I collect?

The default is 100 listings per query and 1,000 per run. You can raise the
limits to 2,400 per query and 120,000 per run, subject to a maximum of 10 pages
per query. Set a result limit to `0` to use the corresponding hard safety cap.

#### Which eBay marketplaces are supported?

The Actor supports US, UK, Germany, Australia, Canada, France, Italy, Spain,
Netherlands, Ireland, Austria, Switzerland, and Poland. Choose one marketplace
per run; schedule or start separate runs to compare multiple markets.

### Responsible use

This is an unofficial, independently developed tool. It is not affiliated with,
endorsed by, or sponsored by eBay Inc. eBay names and trademarks belong to
their respective owners.

The Actor collects information publicly displayed in eBay search results. You
are responsible for using the data in accordance with applicable laws,
regulations, and eBay's terms. Avoid collecting or processing personal data
without a lawful purpose.

# Actor input Schema

## `queries` (type: `array`):

One to fifty active-listing search queries.

## `marketplace` (type: `string`):

eBay marketplace used for localized active listings.

## `maxResultsPerQuery` (type: `integer`):

Stop persisting a query after this many unique records. Set to 0 for unlimited results within the page and Actor safety limits.

## `sortOrder` (type: `string`):

Ordering applied by eBay before pages are collected.

## `minPrice` (type: `number`):

Optional marketplace-currency lower price bound.

## `maxPrice` (type: `number`):

Optional marketplace-currency upper price bound.

## `itemLocation` (type: `string`):

Location filter applied directly to eBay. Domestic means the selected marketplace's home country.

## `condition` (type: `string`):

Condition filter applied directly to eBay. Refurbished includes Certified, Excellent, Very Good, and Good refurbished grades.

## `buyingFormat` (type: `string`):

Buying-format filter applied directly to eBay. Any omits all format parameters.

## `maxPagesPerQuery` (type: `integer`):

Advanced request-effort cap for each search query.

## `maxTotalResults` (type: `integer`):

Advanced whole-run cap across every query. Set to 0 for unlimited results within the Actor safety limit.

## Actor input object example

```json
{
  "queries": [
    "iphone 15 pro"
  ],
  "marketplace": "US",
  "maxResultsPerQuery": 100,
  "sortOrder": "BEST_MATCH",
  "itemLocation": "DEFAULT",
  "condition": "ANY",
  "buyingFormat": "ANY",
  "maxPagesPerQuery": 5,
  "maxTotalResults": 1000
}
```

# Actor output Schema

## `listings` (type: `string`):

No description

## `runReport` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "iphone 15 pro"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("astravalabs/ebay-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 = { "queries": ["iphone 15 pro"] }

# Run the Actor and wait for it to finish
run = client.actor("astravalabs/ebay-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 '{
  "queries": [
    "iphone 15 pro"
  ]
}' |
apify call astravalabs/ebay-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Listings Scraper – Prices & Auctions",
        "description": "eBay listings scraper for price monitoring and market research across 13 marketplaces. Extract up to 60 fields, including prices, shipping, sellers, bids, watchers, sold counts, promotions, and sponsored results. Not affiliated with eBay Inc.",
        "version": "0.0",
        "x-build-id": "Sd6rhCB7lLsSj0r1W"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/astravalabs~ebay-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-astravalabs-ebay-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/astravalabs~ebay-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-astravalabs-ebay-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/astravalabs~ebay-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-astravalabs-ebay-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",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "minItems": 1,
                        "maxItems": 50,
                        "type": "array",
                        "description": "One to fifty active-listing search queries.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "iphone 15 pro"
                        ]
                    },
                    "marketplace": {
                        "title": "Marketplace",
                        "enum": [
                            "US",
                            "UK",
                            "DE",
                            "AU",
                            "CA",
                            "FR",
                            "IT",
                            "ES",
                            "NL",
                            "IE",
                            "AT",
                            "CH",
                            "PL"
                        ],
                        "type": "string",
                        "description": "eBay marketplace used for localized active listings.",
                        "default": "US"
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum results per query",
                        "minimum": 0,
                        "maximum": 2400,
                        "type": "integer",
                        "description": "Stop persisting a query after this many unique records. Set to 0 for unlimited results within the page and Actor safety limits.",
                        "default": 100
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "BEST_MATCH",
                            "TIME_ENDING_SOONEST",
                            "TIME_NEWLY_LISTED",
                            "PRICE_LOW_TO_HIGH",
                            "PRICE_HIGH_TO_LOW",
                            "DISTANCE_NEAREST_FIRST"
                        ],
                        "type": "string",
                        "description": "Ordering applied by eBay before pages are collected.",
                        "default": "BEST_MATCH"
                    },
                    "minPrice": {
                        "title": "Minimum displayed price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Optional marketplace-currency lower price bound."
                    },
                    "maxPrice": {
                        "title": "Maximum displayed price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Optional marketplace-currency upper price bound."
                    },
                    "itemLocation": {
                        "title": "Item location",
                        "enum": [
                            "DEFAULT",
                            "DOMESTIC",
                            "WORLDWIDE"
                        ],
                        "type": "string",
                        "description": "Location filter applied directly to eBay. Domestic means the selected marketplace's home country.",
                        "default": "DEFAULT"
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "ANY",
                            "NEW",
                            "OPEN_BOX",
                            "REFURBISHED",
                            "USED",
                            "FOR_PARTS"
                        ],
                        "type": "string",
                        "description": "Condition filter applied directly to eBay. Refurbished includes Certified, Excellent, Very Good, and Good refurbished grades.",
                        "default": "ANY"
                    },
                    "buyingFormat": {
                        "title": "Buying format",
                        "enum": [
                            "ANY",
                            "AUCTION",
                            "BUY_IT_NOW",
                            "ACCEPTS_OFFERS"
                        ],
                        "type": "string",
                        "description": "Buying-format filter applied directly to eBay. Any omits all format parameters.",
                        "default": "ANY"
                    },
                    "maxPagesPerQuery": {
                        "title": "Maximum pages per query",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Advanced request-effort cap for each search query.",
                        "default": 5
                    },
                    "maxTotalResults": {
                        "title": "Maximum results for the run",
                        "minimum": 0,
                        "maximum": 120000,
                        "type": "integer",
                        "description": "Advanced whole-run cap across every query. Set to 0 for unlimited results within the Actor safety limit.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
