# eBay Search Scraper: Active Listings & Prices, No Login (`cliqtomedia/ebay-browse-search`) Actor

Search active eBay listings by keyword or category on 16 eBay sites: price, condition, seller feedback, shipping, bids and links. Official eBay Browse API with your own free key. No login.

- **URL**: https://apify.com/cliqtomedia/ebay-browse-search.md
- **Developed by:** [Cliqto Media](https://apify.com/cliqtomedia) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.89 / 1,000 listing saveds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Search **active eBay listings** by keyword or category on 16 eBay sites and get price, condition, seller feedback, shipping, bids and links as clean rows. The Actor calls the **official eBay Browse API with your own free eBay developer keyset**: no eBay account login, no browser, no proxies, no blocked pages.

Good for sellers checking competitor prices, resellers looking for deals, repricing tools and analysts who need a stable eBay search feed. The smallest run is one keyword and 10 listings: about 5 seconds and $0.029.

![eBay Active Listings Search: a keyword search on eBay US returns active listings with price, seller feedback and Buy It Now or auction format, using your own eBay keyset with the daily quota checked first](https://api.apify.com/v2/key-value-stores/kgfhrWefgQJs9WWFj/records/hero.png)

> **An eBay key is required.** You need a free eBay developer keyset (Client ID and Client Secret). Without it the run ends with one free `api_key_required` row that explains how to get the key. There is no demo mode and no sample data. Apify still charges the small automatic Actor start fee for that run ($0.002).

### Table of contents

- [What it does](#what-it-does)
- [How to get your eBay keys](#how-to-get-your-ebay-keys)
- [Quick start](#quick-start)
- [Use cases](#use-cases)
- [Input](#input)
- [Output](#output)
- [Pricing](#pricing)
- [Limits](#limits)
- [API, export and integrations](#api-export-and-integrations)
- [Troubleshooting](#troubleshooting)
- [FAQ](#faq)
- [Related Actors](#related-actors)
- [Support](#support)

### What it does

For each keyword or category you give, the Actor asks eBay's Browse API for **listings that are live right now** and saves one row per listing:

- price and currency, with the current bid and bid count for auctions;
- condition, seller username, seller feedback percent and score;
- buying options (Buy It Now, auction, best offer), shipping cost, delivery window;
- item location, category, listing start and end time, product ID (ePID);
- clean listing URL and a large image URL.

It works on 16 eBay sites (US, UK, Germany, Australia, Canada, France, Italy, Spain, Netherlands, Belgium, Austria, Switzerland, Ireland, Poland, Hong Kong, Singapore). eBay filters by price, condition, buying format, item country and delivery country on its side.

#### Good fit

- You want today's asking prices for a product, not what it sold for.
- You want eBay data from the official API instead of a page scraper that breaks when eBay changes its pages.
- You can create a free eBay developer account (5 minutes).

#### Not a fit

- **Sold or completed listings.** The Browse API only returns active listings. For sold prices, see [Related Actors](#related-actors).
- Full item descriptions, all item specifics or seller contact details.
- Running without an eBay keyset.

#### How it works

1. The Actor gets an application token for your keyset (OAuth client credentials).
2. It reads how many Browse API calls your keyset has left today. If none are left, it stops before searching.
3. It runs each search page by page (up to 200 listings per call), drops listings already saved by an earlier search in the same run and writes rows to the Dataset.
4. It writes a `RUN_SUMMARY` record with counts, quota used, warnings and the stop reason.

### How to get your eBay keys

The keyset is free. eBay does not charge for the Developers Program or for Browse API calls.

1. Sign up at the [eBay Developers Program](https://developer.ebay.com/) and confirm your email.
2. Open [Application Keys](https://developer.ebay.com/my/keys) and create a **Production** keyset (not Sandbox).
3. Copy the **App ID (Client ID)** and the **Cert ID (Client Secret)** into the Actor input. Both fields are secret: Apify stores them encrypted and the Actor never writes them to logs or results.

eBay gives each keyset **5,000 Browse API calls a day** ([eBay API call limits](https://developer.ebay.com/develop/get-started/api-call-limits)). One call returns up to 200 listings, so the daily quota covers up to about 1,000,000 listings. The quota resets once a day; the run summary shows the reset time.

eBay's Buy APIs are formally meant for eBay partners, and eBay can limit access for a keyset. Your keyset is used only inside your own run. If eBay refuses the key, the run fails with a clear message instead of returning empty results.

### Quick start

1. Paste your Client ID and Client Secret.
2. Keep the prefilled search (`iphone 13`, 10 listings) or type your own keywords.
3. Click **Start**. Rows appear in the **Output** tab in a few seconds.

```json
{
  "clientId": "YOUR-CLIENT-ID",
  "clientSecret": "YOUR-CLIENT-SECRET",
  "queries": ["iphone 13"],
  "maxItems": 10
}
```

### Use cases

- **Competitor prices.** Search your product with `condition: "new"` and `sort: "priceLowToHigh"` to see the cheapest live offers with shipping.
- **Deal finding.** Use `priceMax` and `buyingFormat: "auction"` with `sort: "endingSoonest"` to see auctions that end soon.
- **Category feed.** Pass only `categoryIds` to list items in an eBay category without a keyword.
- **Cross-site comparison.** Run the same keywords on `EBAY_US`, `EBAY_GB` and `EBAY_DE` and compare `price` and `currency`.
- **Repricing input.** Schedule a daily run and send `itemId`, `price` and `shippingCost` to your sheet or database.

### Input

#### Input fields

| Field | Type | Default | What it does |
| --- | --- | --- | --- |
| `clientId` | secret string | — | eBay App ID (Client ID). Required. |
| `clientSecret` | secret string | — | eBay Cert ID (Client Secret). Required. |
| `queries` | list of strings | `["iphone 13"]` in the form | Keywords. Each keyword is one search. Up to 50. |
| `categoryIds` | list of strings | — | eBay category IDs, up to 10. With keywords, every keyword is searched in every category (up to 100 searches). Without keywords, the category is listed. |
| `marketplace` | one of 16 sites | `EBAY_US` | eBay site. Prices are in the site's currency. |
| `maxItems` | integer | 100 (10 in the form) | Listings per search, 1–10,000. |
| `sort` | choice | `bestMatch` | `bestMatch`, `priceLowToHigh`, `priceHighToLow`, `newlyListed`, `endingSoonest`. eBay sorts by price **plus shipping**. |
| `titleMustMatch` | boolean | `false` | Keep only listings whose title has every keyword. See below. |
| `priceMin` / `priceMax` | integer | — | Price range in the site's currency. |
| `condition` | choice | `any` | `any`, `new`, `used`. |
| `buyingFormat` | choice | `all` | `all`, `fixed_price`, `auction`, `best_offer`. |
| `itemLocationCountry` | 2-letter code | — | Only items located in this country, for example `US`. |
| `deliveryCountry` / `deliveryPostalCode` | code / text | — | Only items that ship there; shipping cost is calculated for that place. |

#### Settings that work together

- **Keywords and categories.** 3 keywords × 2 categories = 6 searches; `maxItems` applies to each search.
- **Duplicates.** A listing found by two searches is saved once, with the first search's `query`.
- **`titleMustMatch`.** eBay's API also matches keywords in item specifics, so a search for `lego technic` can return sets that only mention Technic in their details. With this option the Actor reads full pages of 200 and keeps only titles that contain every keyword. Dropped listings are not saved or charged. Each search scans at most 5 times the pages `maxItems` needs and never more than 1,600 listings. If no title matches, the search gets one `no_results` row.
- **Auctions.** `buyingFormat: "all"` includes both Buy It Now and auctions. eBay's own default is Buy It Now only; the Actor asks for both.

#### Input examples

Cheapest new LEGO Technic sets on eBay Germany, up to €200, titles must say "lego technic":

```json
{
  "clientId": "YOUR-CLIENT-ID",
  "clientSecret": "YOUR-CLIENT-SECRET",
  "queries": ["lego technic"],
  "marketplace": "EBAY_DE",
  "condition": "new",
  "priceMax": 200,
  "sort": "priceLowToHigh",
  "titleMustMatch": true,
  "maxItems": 20
}
```

Vintage watch auctions on eBay UK that end soonest:

```json
{
  "clientId": "YOUR-CLIENT-ID",
  "clientSecret": "YOUR-CLIENT-SECRET",
  "queries": ["vintage watch"],
  "marketplace": "EBAY_GB",
  "buyingFormat": "auction",
  "sort": "endingSoonest",
  "maxItems": 20
}
```

### Output

One Dataset row per listing. The **Listings** view in the Output tab shows the main columns; export gives all 40 fields.

#### Output fields

| Field | Type | Can be null | Meaning |
| --- | --- | --- | --- |
| `status` | string | no | `ok` (a listing), `no_results` (a search with no listings) or `api_key_required` (no key given). |
| `itemId` | string | yes¹ | eBay item number, as in the listing URL, e.g. `237128712651`. |
| `browseItemId` | string | yes¹ | Item ID in eBay's API format, e.g. `v1|237128712651|0`. |
| `title` | string | yes¹ | Listing title. |
| `price` | number | yes | Price in the site's currency. Auctions without Buy It Now show the current bid. |
| `currency` | string | yes | `USD`, `GBP`, `EUR` and so on. |
| `priceType` | string | yes | `fixed` or `current_bid`. |
| `currentBid` | number | yes | Current bid; `null` for listings without an auction. |
| `bidCount` | integer | yes | Number of bids; `null` for listings without an auction. |
| `originalPrice` | number | yes | Strike-through price, when the seller shows a discount. |
| `discountPercent` | number | yes | Discount from `originalPrice`, e.g. `15`. |
| `condition` | string | yes | eBay condition name in the site's language, e.g. `Pre-owned - Fair` or `Neu`. |
| `conditionId` | string | yes | eBay condition ID, e.g. `1000` (new). |
| `seller` | string | yes | Seller username (see FAQ for why it can be `null`). |
| `sellerFeedbackPercent` | number | yes | Positive feedback, e.g. `99.8`. |
| `sellerFeedbackScore` | integer | yes | Feedback score, e.g. `3326`. |
| `buyingOptions` | array of strings | yes | e.g. `["FIXED_PRICE", "BEST_OFFER"]` or `["AUCTION"]`. |
| `shippingCost` | number | yes | Cheapest shipping option; `0` for free shipping; `null` when shipping is `CALCULATED` and no delivery place is set. |
| `shippingCostType` | string | yes | `FIXED` or `CALCULATED`. |
| `deliveryFrom`, `deliveryTo` | string (ISO date) | yes | Estimated delivery window, when eBay gives one. |
| `location` | string | yes | Item location, postcode partly hidden by eBay, e.g. `NN16***, GB`. |
| `locationCountry` | string | yes | 2-letter country code, e.g. `GB`. |
| `categoryId`, `categoryName` | string | yes | Leaf category, e.g. `31387`, `Wristwatches`. |
| `listedAt` | string (ISO date) | yes | When the listing started. |
| `endsAt` | string (ISO date) | yes | When the listing ends (auctions, and some fixed-price listings). |
| `topRatedBuyingExperience` | boolean | yes | eBay Top Rated Plus listing. |
| `priorityListing` | boolean | yes | Promoted listing. |
| `epid` | string | yes | eBay product ID, when the listing is linked to a catalog product. |
| `itemGroupType` | string | yes | Set for listings with variations (sizes, colours). |
| `url` | string | yes¹ | Clean listing URL without tracking. |
| `image` | string | yes | Large image URL. |
| `marketplace` | string | no | eBay site of the search, e.g. `EBAY_US`. |
| `query` | string | yes | Keyword that found the row; `null` for a category-only search. |
| `categoryFilter` | string | yes | Category ID of the search, if any. |
| `position` | integer | yes¹ | Place in eBay's order, starting at 1. |
| `source` | string | no | Always `ebay-browse-api`. |
| `fetchedAt` | string (ISO date) | no | When the row was read. |
| `message` | string | yes | Explanation on `no_results` and `api_key_required` rows; `null` on listings. |

¹ Always filled on `ok` rows; `null` on `no_results` and `api_key_required` rows.

Good to know:

- **Variations.** For a listing with several sizes or colours, `price` is the price eBay's API shows for one variation, not the "from – to" range on the eBay page.
- **Auction with Buy It Now.** `price` is the Buy It Now price, `priceType` is `fixed`, and `currentBid` still shows the bid.
- **Freshness.** Prices and bids change all the time. Each row has `fetchedAt`. eBay's terms ask API users not to keep listing data longer than 6 hours; run again for fresh data.

#### Output example

```json
{
  "status": "ok",
  "itemId": "237128712651",
  "title": "VINTAGE WATCHES SPARES AND REPAIRS ONLY (LOT 59) 12 IN TOTAL, MANY MORE TO LIST",
  "price": 25,
  "currency": "GBP",
  "priceType": "current_bid",
  "currentBid": 25,
  "bidCount": 6,
  "condition": "Pre-owned - Fair",
  "seller": "example_seller",
  "sellerFeedbackPercent": 100,
  "sellerFeedbackScore": 3326,
  "buyingOptions": ["AUCTION"],
  "shippingCost": 6.2,
  "shippingCostType": "FIXED",
  "location": "NN16***, GB",
  "categoryId": "31387",
  "categoryName": "Wristwatches",
  "listedAt": "2026-10-17T10:47:23.000Z",
  "endsAt": "2026-10-22T10:47:23.000Z",
  "url": "https://www.ebay.co.uk/itm/237128712651",
  "image": "https://i.ebayimg.com/images/g/9MAAAeSwojpq00~m/s-l1200.jpg",
  "marketplace": "EBAY_GB",
  "query": "vintage watch",
  "position": 2,
  "fetchedAt": "2026-10-22T10:46:39.419Z"
}
```

The seller username is replaced with `example_seller` in this example.

A search with no listings gives one row like this (charged as an empty result):

```json
{
  "status": "no_results",
  "marketplace": "EBAY_FR",
  "query": "zzqqxxnonexistent987 qwvbn",
  "message": "eBay has no active listings for \"zzqqxxnonexistent987 qwvbn\" with these filters on EBAY_FR."
}
```

#### Run summary

The `RUN_SUMMARY` record in the run's key-value store has `status` (`COMPLETE`, `PARTIAL`, `NO_RESULTS`, `API_KEY_REQUIRED`, `INVALID_INPUT` or `ERROR`), `stopReason` (`QUOTA_LIMIT`, `CHARGE_LIMIT`, `TIME_LIMIT`, `SOURCE_ERROR`), counts, quota before the run and calls used, one line per search with eBay's total match count, and warnings.

#### Coming from an eBay page scraper?

| Page-scraper field | This Actor |
| --- | --- |
| `price` text / `priceValue` | `price` (number) + `currency` |
| `sellerUsername` | `seller` |
| `sellerFeedbackPercentage` | `sellerFeedbackPercent` |
| `buyingFormat` | `buyingOptions` and `priceType` |
| `itemLocation` | `location`, `locationCountry` |
| `totalPrice` | `price` + `shippingCost` |
| `discount` | `discountPercent` |

Field names differ, so this is not a drop-in replacement for another Actor's output.

### Pricing

This Actor uses **pay per event**. Apify platform usage is included in the event prices. eBay does not charge for the API.

| Event | When it is charged | Free | Bronze | Silver | Gold+ |
| --- | --- | ---: | ---: | ---: | ---: |
| Actor start | once per run, per GB of memory (default 256 MB = 1 event); also on a run without a key | $0.002 | $0.002 | $0.002 | $0.002 |
| Listing | each `ok` row saved to the Dataset | $0.0027 | $0.00243 | $0.00216 | $0.00189 |
| Empty result | each search with no listings (one `no_results` row) | $0.002 | $0.002 | $0.002 | $0.002 |

That is **$2.70 per 1,000 listings** on the Free plan and $1.89 on Gold. Duplicates, listings dropped by `titleMustMatch` and the `api_key_required` row are not charged.

#### Cost examples (Free plan)

| Run | Rows | Price | Time (measured) |
| --- | ---: | ---: | ---: |
| Prefill: 1 keyword, 10 listings | 10 | $0.002 + $0.027 = **$0.029** | ~5 s |
| 1 keyword, 100 listings | 100 | $0.002 + $0.27 = **$0.272** | ~5 s |
| 1 keyword, 1,000 listings | 1,000 | $0.002 + $2.70 = **$2.702** | ~15 s |
| 1 keyword, `maxItems` 10,000 | 9,509 unique | $0.002 + $25.67 = **$25.68** | ~3.5 min |
| 1 keyword, nothing found | 1 `no_results` | $0.002 + $0.002 = **$0.004** | ~3 s |
| No key | 1 free row | **$0.002** | ~1 s |

- **Max cost per run:** set it in the run options. The Actor stops before a row it cannot pay for, keeps what it saved and ends **Succeeded** with status `PARTIAL` / `CHARGE_LIMIT`.
- **Quota runs out mid-run:** the Actor stops before the next call, keeps what it saved and ends **Succeeded** with `PARTIAL` / `QUOTA_LIMIT` and the reset time. You pay only for saved rows.

### Limits

- **10,000 listings per search.** eBay's Browse API serves only the first 10,000 results of one search (and a few listings repeat on neighbouring pages, so expect about 9,500 unique). For more, split the search by category, price range or more specific keywords.
- **Up to 100 searches per run** (50 keywords × 10 categories at most).
- **Daily quota of your keyset:** 5,000 calls; each call is up to 200 listings. eBay can raise it through its Application Growth Check.
- **Speed:** calls are sequential to save your quota. About 3–4 seconds per 200 listings: 1,000 listings in about 15 seconds, 5 searches × 10,000 in about 13 minutes (measured). The default run timeout is 30 minutes; the Actor stops 15 seconds before it, keeps saved rows and ends **Succeeded** with `PARTIAL` / `TIME_LIMIT`. If the timeout is so short that nothing was saved yet, the run fails with the same reason.
- **Active listings only.** No sold listings, no full descriptions, no seller contacts.
- eBay's terms forbid using this data for average selling prices or aggregated seller data; the Actor does not compute them.

### API, export and integrations

- **API:** start a run with `POST https://api.apify.com/v2/acts/cliqtomedia~ebay-browse-search/runs` and the input JSON; read rows from the run's Dataset.
- **Export:** JSON, CSV, Excel, XML or HTML from the Output tab.
- **Scheduling:** save your input as a Task and add a [schedule](https://docs.apify.com/platform/schedules), for example daily with `sort: "newlyListed"`.
- **Webhooks / no-code:** send the Dataset to Google Sheets, Make, Zapier or n8n with [Apify integrations](https://docs.apify.com/platform/integrations).

#### Use with AI agents (MCP)

- MCP server with only this Actor: `https://mcp.apify.com?tools=cliqtomedia/ebay-browse-search`
- Smallest useful input (the agent also needs the user's `clientId` and `clientSecret`):

```json
{ "queries": ["iphone 13"], "maxItems": 10 }
```

- Key output fields: `title`, `price` + `currency` (number in the site's currency), `condition`, `seller` + `sellerFeedbackPercent`, `url`.
- A 10-listing run takes about 5 seconds and costs $0.029. Up to 10,000 listings per search; the keyset allows 5,000 calls a day.

### Troubleshooting

#### The run has one `api_key_required` row

Symptom: no listings, one row with a message about the key.
Reason: `clientId` or `clientSecret` is empty.
Action: create a Production keyset as in [How to get your eBay keys](#how-to-get-your-ebay-keys) and paste both values.

#### The run failed with "eBay rejected your keyset"

Symptom: run status Failed, `RUN_SUMMARY.status` `ERROR`.
Likely reason: Sandbox keys, a typo, a deleted keyset, or eBay limited Buy API access for this keyset.
Check: the keys in [Application Keys](https://developer.ebay.com/my/keys) under **Production**.
Action: copy both values again. If eBay limited access, contact eBay developer support.

#### The run stopped with `QUOTA_LIMIT`

Symptom: status Succeeded, `PARTIAL` / `QUOTA_LIMIT`, fewer rows than asked.
Reason: your keyset used its 5,000 calls for today (other apps using the same keyset count too).
Action: run again after the reset time in the status message, or lower `maxItems`.

#### Search results look unrelated to my keyword

Reason: eBay's API also matches words in item specifics, and price sorting adds shipping.
Action: turn on `titleMustMatch`, add a category, or use more specific keywords.

#### `shippingCost` is empty

Reason: the seller uses calculated shipping and eBay needs a destination.
Action: set `deliveryCountry` and `deliveryPostalCode`.

### FAQ

#### Do I need an eBay account or a paid plan?

You need a free eBay developer account to create the keyset. You do not log in to eBay in the Actor, and eBay does not charge for Browse API calls.

#### Is my key safe?

The key fields are secret inputs: Apify stores them encrypted, and the Actor sends them only to eBay's token endpoint. They are not written to the log, the Dataset or the run summary.

#### Why is `seller` sometimes null?

Since September 2025 eBay hides US seller usernames from some API developers. The field is then `null`; feedback percent and score are still filled when eBay gives them.

#### Why did a search return fewer rows than `maxItems`?

eBay has fewer active listings for those filters, or the search hit eBay's 10,000-result cap. The run summary shows eBay's total and a `moreAvailable` flag for each search.

#### Do I pay for a run that finds nothing?

You pay the start fee and $0.002 per search with no listings. A run without a key costs only the start fee.

#### Can I get sold prices?

No. The Browse API returns only active listings. See [Related Actors](#related-actors).

### Related Actors

- [eBay Sold Listings Scraper](https://apify.com/cliqtomedia/ebay-sold-listings) — what items actually sold for: sold price, sale date, condition and bids. Use it next to this Actor to compare asking prices with real sale prices.

### Support

For a bug, question or feature request, open the **Issues** tab of this Actor on Apify. Include the run ID, the marketplace and the input without your keys. Never post your Client ID or Client Secret.

# Changelog

This Actor's version history is a separate document: https://apify.com/cliqtomedia/ebay-browse-search/changelog.md

# Actor input Schema

## `clientId` (type: `string`):

App ID (Client ID) of your Production keyset from developer.ebay.com/my/keys. Stored encrypted; never written to the dataset, logs or run summary.

## `clientSecret` (type: `string`):

Cert ID (Client Secret) of the same Production keyset. Stored encrypted; never written to the dataset, logs or run summary.

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

One search per line, as you would type it on eBay, up to 50. Each search returns up to Max listings per search. Leave empty to list a whole category from Category IDs.

## `categoryIds` (type: `array`):

Optional numeric eBay category IDs, up to 10, e.g. 9355 for Cell Phones & Smartphones on eBay.com. With keywords, every keyword is searched in every category (up to 100 searches). The number is in the category page URL on eBay, e.g. ebay.com/b/…/9355/bn\_….

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

Which eBay site to search. Prices, the price filter and shipping use that site's currency.

## `maxItems` (type: `integer`):

Stop each search after this many listings (eBay serves up to 10,000 per search). Each saved listing is one paid result; every 200 listings use one of your 5,000 daily API calls.

## `sort` (type: `string`):

Order of results, as eBay sorts them. Price sorting uses the item price plus the cheapest shipping cost.

## `titleMustMatch` (type: `boolean`):

Keep only listings whose title contains every word of the keyword. eBay's API also matches words in item specifics, so price-sorted searches can start with loosely related items. Dropped listings are not saved or charged; each search then reads full pages of 200 and scans at most 5 times the pages maxItems needs and never more than 1,600 listings per search.

## `priceMin` (type: `integer`):

Only listings at or above this price, in the eBay site's currency (whole units).

## `priceMax` (type: `integer`):

Only listings at or below this price, in the eBay site's currency (whole units).

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

Item condition.

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

Listing format.

## `itemLocationCountry` (type: `string`):

Optional two-letter country code: only items located there, e.g. US, GB, DE, CN.

## `deliveryCountry` (type: `string`):

Optional two-letter country code: only items that ship there, with shipping cost and delivery dates for that country.

## `deliveryPostalCode` (type: `string`):

Optional postal code with Ship to country, for more exact shipping costs, e.g. 10001.

## Actor input object example

```json
{
  "queries": [
    "iphone 13",
    "lego star wars 75192"
  ],
  "categoryIds": [
    "9355"
  ],
  "marketplace": "EBAY_US",
  "maxItems": 10,
  "sort": "bestMatch",
  "titleMustMatch": false,
  "condition": "any",
  "buyingFormat": "all",
  "itemLocationCountry": "US",
  "deliveryCountry": "DE",
  "deliveryPostalCode": "10001"
}
```

# Actor output Schema

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

Active eBay listings as a table, search by search, in the sort order you chose.

## `runSummary` (type: `string`):

Status, stop reason, counts per search and your keyset's daily Browse API calls.

# 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 13"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("cliqtomedia/ebay-browse-search").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 13"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("cliqtomedia/ebay-browse-search").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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 13"
  ],
  "maxItems": 10
}' |
apify call cliqtomedia/ebay-browse-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cliqtomedia/ebay-browse-search"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5SdlD67YSgf6sTWrd/builds/71ce09L4sqiQPubwi/openapi.json