# eBay Scraper - Listings, Prices & Price Stats (`groupoject/ebay-scraper`) Actor

eBay scraper for search results by keyword or URL on 8 eBay sites: price, shipping, total, condition, bids, sold count, watchers, seller feedback, location and image, plus a min/median/average/max price summary per search. JSON, CSV, Excel.

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

## Pricing

from $1.40 / 1,000 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/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

## eBay Scraper - Listings, Prices & Price Stats

This eBay scraper pulls eBay search results by keyword or URL from 8 eBay sites. Each row has the item price, shipping, total price, condition, format, bids, sold count, seller feedback, location and image. Each search also gets a price summary with the min, median, average and max price, so you can price an item without opening a spreadsheet.

> **Sold listings and eBay sign-in (October 2026).** eBay now sends most logged-out visitors who open sold or completed searches to its sign-in page. This actor never logs in. In `sold` or `completed` mode it tries several fresh proxy sessions. If eBay still asks for sign-in, the search is recorded in the `ERRORS` record with the code `SOLD_LISTINGS_SIGNIN_REQUIRED` and **nothing is charged**. Active-listing searches (`mode: "active"`) are not affected and work on all 8 sites.

![eBay Scraper output in Apify: listing image, title, price, currency, shipping, total price, condition and listing type](https://api.apify.com/v2/key-value-stores/lwQu1lCMCLQIIhSMQ/records/ebay-scraper-output.png)

*Real output from a default run of eBay Scraper in Apify Console.*

### What can this eBay scraper do?

- **Search by keyword or paste eBay URLs.** Run many keywords in one go, or paste search and category URLs straight from eBay. A pasted URL keeps every filter you set on eBay.
- **Cover 8 eBay sites:** ebay.com, ebay.co.uk, ebay.de, ebay.ca, ebay.com.au, ebay.fr, ebay.it and ebay.es. Prices come back as numbers with an ISO currency code. The parser understands each site's price format and its labels in English, German, French, Italian and Spanish.
- **Filter on eBay's side:** condition (new, open box, refurbished, used, for parts), minimum and maximum price, auction / Buy It Now / accepts offers, category ID, free shipping only and sort order.
- **Pick a mode:** `active` for live listings with asking prices, `sold` for sold prices and sold dates, or `completed` for every ended listing, sold and unsold, with a sell-through rate.
- **Get price statistics per search.** The `SUMMARY` record has count, min, 25th percentile, median, average, 75th percentile and max for the item price and for price + shipping. It also has listing-type and condition breakdowns and the free-shipping share. This record is not billed.
- **Use a sold date cutoff.** Keep only sales from the last N days or after a given date. Older rows are dropped before they are saved, so you don't pay for them.
- **Monitor new listings and price drops.** Turn on `onlyNew` and schedule the run: each run saves only listings it has not seen before, and with `alertOnPriceDrop` also listings whose total price dropped. Skipped listings are not billed.
- **Avoid duplicate charges.** Items that show up on two pages or in two searches are saved once.
- **Respect your spending limit.** The run stops cleanly at the maximum charge you set.

### What data do you get?

| Field | Description |
|---|---|
| `itemId`, `url` | eBay item number and listing link |
| `title`, `subtitle` | Listing title and the seller's subtitle line |
| `listingStatus` | `active`, `sold` or `unsold` |
| `price`, `priceMax`, `currency` | Item price as a number (sold price for sold rows, asking price or current bid for active rows), top of a price range, ISO currency |
| `originalPrice` | Struck-through "was" price when eBay shows a discount |
| `buyItNowPrice` | Buy It Now price of an auction that also offers it |
| `shippingCost`, `freeShipping`, `totalPrice` | Shipping (0 = free, null = not shown) and price + shipping |
| `soldDate`, `soldDateText` | Sold date as `YYYY-MM-DD` and eBay's original label (sold rows) |
| `timeLeft` | Time left on an active auction |
| `condition`, `conditionNormalized` | eBay's condition label in the site's language, plus `new` / `open_box` / `refurbished` / `used` / `for_parts` / `other` |
| `listingType`, `bestOfferAccepted` | `auction`, `auction_with_bin`, `buy_it_now`, `best_offer` or `best_offer_accepted` |
| `bidsCount`, `soldCount`, `watchersCount` | Bids, "N sold" on multi-quantity listings, watchers |
| `sellerName`, `sellerFeedbackPercent`, `sellerFeedbackCount`, `sellerType` | Seller details as shown on the search card. On EU sites eBay often shows only private/business. |
| `location` | Item location when eBay shows it (often only for items outside the site's country) |
| `imageUrl`, `imageUrlLarge` | Main image at 500 px and 1600 px |
| `marketplace`, `searchQuery`, `searchUrl`, `page`, `position`, `scrapedAt` | Where and when the row was found |
| `isNew`, `priceDropped`, `previousPrice`, `priceChangePct` | Monitoring runs only: new since the last run, total price lower than last time, last total price, change in % |

The scraper reads search result pages only. It does not open item pages, so item specifics and full descriptions are not included.

### How much does it cost?

You pay per listing saved: **$2.00 per 1,000 results**. The price summary, run statistics and error report are free key-value records. Searches that eBay sends to sign-in are not billed.

On paid Apify plans the per-result price drops automatically (Bronze and above get volume discounts); the Pricing tab shows your exact rate.

- **Price check for one product.** 1 keyword × 200 listings = 200 results ≈ **$0.40**.
- **Weekly market scan.** 25 keywords × 240 listings every week ≈ 6,000 results a week ≈ **$12 a week**.

Set a maximum charge per run in Apify Console and the scraper stops at that limit.

### How to use it

1. Open the actor and add one or more **Search keywords**, or paste **eBay search URLs**.
2. Choose the **eBay marketplace** and **Mode** (`active`, `sold` or `completed`).
3. Optionally set condition, price range, listing type, category ID, sort order and a sold date cutoff.
4. Set **Max items per search** and click **Start**.
5. Listings appear in the **Output** tab. Price statistics per search are in the `SUMMARY` record of the key-value store, and anything that failed is in `ERRORS`.

#### Input example

```json
{
  "keywords": ["nintendo switch oled", "steam deck 512gb"],
  "mode": "active",
  "marketplace": "ebay.com",
  "conditions": ["used"],
  "minPrice": 100,
  "listingType": "all",
  "maxItemsPerSearch": 240
}
```

### Output example

One dataset row (values are illustrative):

```json
{
  "itemId": "135500000001",
  "url": "https://www.ebay.com/itm/135500000001",
  "title": "Nintendo Switch OLED 64GB White - Console Only - Tested",
  "listingStatus": "active",
  "price": 189.99,
  "priceMax": null,
  "currency": "USD",
  "originalPrice": null,
  "buyItNowPrice": null,
  "shippingCost": 0,
  "freeShipping": true,
  "totalPrice": 189.99,
  "soldDate": null,
  "soldDateText": null,
  "endedDateText": null,
  "timeLeft": null,
  "condition": "Pre-Owned",
  "conditionNormalized": "used",
  "listingType": "buy_it_now",
  "bestOfferAccepted": false,
  "bidsCount": null,
  "soldCount": 41,
  "watchersCount": null,
  "sellerName": "example_games_outlet",
  "sellerFeedbackPercent": 99.4,
  "sellerFeedbackCount": 4300,
  "sellerType": null,
  "location": "United States",
  "imageUrl": "https://i.ebayimg.com/images/g/EXAMPLE/s-l500.webp",
  "imageUrlLarge": "https://i.ebayimg.com/images/g/EXAMPLE/s-l1600.webp",
  "subtitle": "Nintendo Switch · Nintendo Switch (OLED Model)",
  "marketplace": "ebay.com",
  "searchQuery": "nintendo switch oled",
  "searchUrl": "https://www.ebay.com/sch/i.html?_nkw=nintendo+switch+oled&_sacat=0&_ipg=240",
  "page": 1,
  "position": 1,
  "scrapedAt": "2026-10-26T20:05:19.144Z"
}
```

The `SUMMARY` record (one entry per search, shortened):

```json
{
  "searches": [
    {
      "searchQuery": "nintendo switch oled",
      "marketplace": "ebay.com",
      "mode": "active",
      "status": "ok",
      "totalResultsOnEbay": 6600,
      "itemsPushed": 240,
      "currency": "USD",
      "price": { "count": 240, "min": 120, "p25": 170, "median": 199.99, "average": 212.4, "p75": 245, "max": 429 },
      "totalPrice": { "count": 240, "min": 128.5, "p25": 178.2, "median": 206.06, "average": 219.8, "p75": 249.18, "max": 439.99 },
      "byListingType": { "buy_it_now": 131, "best_offer": 96, "auction": 13 },
      "byCondition": { "used": 178, "open_box": 31, "refurbished": 22, "new": 9 },
      "freeShippingShare": 0.46
    }
  ]
}
```

In `sold` and `completed` mode the statistics use sold rows only. The summary also includes `soldCount`, `unsoldCount`, `sellThroughRate` (completed mode) and `soldDateRange`.

### Monitor new eBay listings and price drops

Resellers and deal hunters usually want to know what changed since the last check, not the same 200 listings again. Monitoring mode remembers every listing it has seen and saves only what is new, so a scheduled run gives you an alert feed for new eBay listings.

1. Set your keywords or eBay search URLs and filters as usual.
2. Turn on **Only new listings** (`onlyNew: true`) and give the monitor a name in **Monitor name** (`stateKey`), for example `switch-oled-us`. Runs with the same name share their history; use a different name per monitor.
3. Optional: turn on **Also alert on price drops** (`alertOnPriceDrop: true`) to also get listings you have seen before whose price + shipping is now lower. Those rows carry `previousPrice` and `priceChangePct`.
4. Optional: set **Alert only at or below total price** (`maxTotalPrice`) to get only deals under your target price, shipping included.
5. Save the input as a task and add a **schedule** in Apify Console (Schedules → Create), for example every hour (`0 * * * *`) for fast-moving items or once a day (`0 8 * * *`) for a daily digest.
6. Add an **integration** to the task: Slack, email, Google Sheets, Make, Zapier, n8n or a webhook. The integration fires after each successful run, and the run's dataset holds only the new listings and price drops, so that is all you are sent.

```json
{
  "keywords": ["nintendo switch oled"],
  "marketplace": "ebay.com",
  "conditions": ["used"],
  "onlyNew": true,
  "alertOnPriceDrop": true,
  "stateKey": "switch-oled-us",
  "maxTotalPrice": 220,
  "maxItemsPerSearch": 120
}
```

How it works:

- The first run saves everything it finds and remembers it. Later runs save only listings that are new, or cheaper when price-drop alerts are on.
- A listing counts as new until any run with the same `stateKey` has seen it once. Price drops compare the total price (price + shipping) with the last run that saw the listing. A drop is reported when the seller cut the item price or made shipping free; small total changes caused only by eBay's location-based shipping estimate are ignored.
- With sort **auto**, active searches are sorted newly listed first, and **Max items per search** is how many of the top results are checked each run. Pick a number larger than the number of new listings you expect between two runs.
- Only saved rows are billed. A run that finds nothing new saves no rows, so no results are charged. Listings above `maxTotalPrice` are remembered but not saved, so if one later drops under your target it is reported as a price drop.
- The history is kept in your named key-value store `ebay-monitor-<stateKey>`. Listings not seen for 120 days are forgotten. To start over, use a new `stateKey` or delete that store.
- The `SUMMARY` record shows how many listings were checked, how many were new and how many dropped in price. The price statistics cover every listing checked, not only the saved rows.

### Use with the API

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/groupoject~ebay-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords":["lego 75192"],"mode":"active","marketplace":"ebay.co.uk","maxItemsPerSearch":100}'
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("groupoject/ebay-scraper").call(run_input={
    "keywords": ["lego 75192"],
    "mode": "active",
    "marketplace": "ebay.co.uk",
    "maxItemsPerSearch": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["price"], item["currency"], item["title"])
summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("SUMMARY")["value"]
print(summary["searches"][0]["price"]["median"])
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('groupoject/ebay-scraper').call({
    keywords: ['lego 75192'],
    mode: 'active',
    marketplace: 'ebay.co.uk',
    maxItemsPerSearch: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const summary = await client.keyValueStore(run.defaultKeyValueStoreId).getRecord('SUMMARY');
console.log(items.length, summary.value.searches[0].price.median);
```

### Use with AI agents / MCP

Connect the Apify MCP server at `https://mcp.apify.com?tools=groupoject/ebay-scraper` in Claude Desktop, Cursor, VS Code or any MCP client. Example prompt: *"Find used Nintendo Switch OLED listings on ebay.com and tell me the median price including shipping."*

### Integrations

Send results to **Google Sheets**, **Make**, **Zapier**, **n8n**, Slack or your own endpoint with Apify integrations and **webhooks**. A common setup is a weekly schedule that writes each search's median price to a sheet.

### FAQ

#### Is it legal to scrape eBay?

The actor collects only what eBay shows to any logged-out visitor on public search pages: titles, prices, conditions, public seller usernames and feedback scores. It does not log in, collect private contact data or solve CAPTCHAs. Check eBay's terms and the data-protection rules that apply to you before you use the data, especially seller names.

#### Why did my sold search return no rows?

eBay currently asks most logged-out visitors to sign in before it shows sold or completed results. The actor does not log in, so these searches end with `SOLD_LISTINGS_SIGNIN_REQUIRED` in the `ERRORS` record and are not charged. Active searches still work. For demand signals without sold mode, use the `soldCount` ("N sold") and `watchersCount` fields on active listings.

#### How many listings can I get per search?

Up to 10,000 per search (`maxItemsPerSearch`), at 240 listings per page. eBay itself rarely serves more than a few thousand results for one query, so split very broad searches by category, condition or price range.

#### Do I need a proxy?

Yes. eBay rejects many automated requests, so the actor uses Apify Proxy. It starts on datacenter proxies, keeps each proxy session's cookies, retries on fresh sessions when eBay shows a block page or a "Pardon our interruption" page, and switches to residential proxies only if datacenter keeps failing (`residentialFallback`).

#### How fast is it?

In local tests a 50-listing search finished in 12–17 seconds, and 1,000 listings took 30–65 seconds on datacenter proxies. Time varies with how often eBay blocks a session.

#### Why are some fields empty?

The actor reads what eBay prints on the search card. eBay doesn't show condition for some categories (antiques, for example). On EU sites it often shows "private"/"business" instead of a seller name, and it shows item location mostly for items located abroad. Empty fields are `null`, not guesses.

#### Can I schedule it to monitor new listings or prices?

Yes. Turn on `onlyNew` (and `alertOnPriceDrop` if you want price drops), set a `stateKey`, save the input as a task and add an hourly or daily schedule. Each run saves only listings that are new since the last run, and an Apify integration can post them to Slack or email. To track the market price instead, run without `onlyNew` and read the median from the `SUMMARY` record. See [Monitor new eBay listings and price drops](#monitor-new-ebay-listings-and-price-drops).

### Related actors

- [Amazon Product Scraper & Price Tracker](https://apify.com/groupoject/amazon-product-intelligence) - compare eBay prices with Amazon prices, ratings and offers across 12 marketplaces.
- [Shopify Scraper - Products, Prices, Variants & SKUs](https://apify.com/groupoject/shopify-product-price-monitor) - track the same products in Shopify stores.
- [Google Flights Scraper & Price Tracker](https://apify.com/groupoject/google-flights-price-monitor) - the same price-tracking approach for airfares.

# Actor input Schema

## `keywords` (type: `array`):

One eBay search per keyword, for example "nintendo switch oled" or "lego 75192". The filters below (condition, price, listing type, category, sort) apply to every keyword.

## `searchUrls` (type: `array`):

Optional. Paste search result URLs copied from eBay (https://www.ebay.com/sch/i.html?...) or category pages (/b/...). A URL keeps the filters you set on eBay; the domain picks the marketplace. If the URL has no sold/completed flag, the Mode below is applied.

## `mode` (type: `string`):

"active" = live listings with asking prices. "sold" = sold listings with sold prices and dates. "completed" = all ended listings, sold and unsold. Note: eBay currently sends many logged-out sold/completed searches to its sign-in page; those searches are listed in the ERRORS record and are not charged.

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

eBay site used for keyword searches. Prices are returned in that site's currency.

## `maxItemsPerSearch` (type: `integer`):

Stop each search after this many rows. eBay shows up to 240 listings per page; every row is one billed result.

## `conditions` (type: `array`):

Only return listings in these conditions. Leave empty for any condition.

## `minPrice` (type: `integer`):

Only listings priced at or above this amount (marketplace currency, shipping excluded).

## `maxPrice` (type: `integer`):

Only listings priced at or below this amount (marketplace currency, shipping excluded).

## `listingType` (type: `string`):

Restrict to auctions, Buy It Now, or listings that accept offers.

## `categoryId` (type: `string`):

Optional numeric eBay category id (the \_sacat value in eBay URLs), for example 139971 for video game consoles.

## `freeShippingOnly` (type: `boolean`):

Only listings with free shipping/delivery.

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

"auto" uses eBay's Best Match for active listings and most recently ended first for sold/completed listings (needed for the sold date cutoff to stop early).

## `soldWithinDays` (type: `integer`):

Sold/completed mode: keep only listings that ended in the last N days. Older rows are dropped before they are saved, so they are not billed.

## `soldAfter` (type: `string`):

Sold/completed mode: keep only listings that ended on or after this date (YYYY-MM-DD). If both cutoffs are set, the later date wins.

## `onlyNew` (type: `boolean`):

Save only listings that earlier runs with the same state key have not seen. Run it on a schedule to get just the new listings each time; skipped listings are not billed. The first run saves everything it finds and remembers it. In active mode with sort "auto", results are sorted newly listed first, and "Max items per search" becomes how many top results are checked each run.

## `alertOnPriceDrop` (type: `boolean`):

With "Only new listings": also save a listing seen before when its total price (price + shipping) is lower than last time. Rows carry previousPrice and priceChangePct. Without "Only new listings", every listing is saved with these comparison fields.

## `stateKey` (type: `string`):

Name of the saved list of seen listings. Use a different name for each separate monitor (for example "ps5-us" and "lego-uk"); runs that share a name share their history. Letters, numbers and dashes are kept.

## `maxTotalPrice` (type: `integer`):

Optional deal threshold: only save listings whose price + shipping is at or below this amount (marketplace currency). Listings above it are still remembered in monitoring mode, so a later drop below it is reported when price-drop alerts are on.

## `dedupeAcrossSearches` (type: `boolean`):

When the same item appears in several searches, save (and bill) it only once.

## `maxConcurrency` (type: `integer`):

How many searches run at the same time. Pages within one search are always fetched in order.

## `proxyConfiguration` (type: `object`):

Apify Proxy is recommended. Datacenter proxies are used first; see the residential fallback option below.

## `residentialFallback` (type: `boolean`):

If eBay keeps blocking datacenter proxies, switch to Apify residential proxies (matched to the marketplace country) for the rest of the run.

## `debugMode` (type: `boolean`):

Log every request outcome. Useful when reporting an issue.

## Actor input object example

```json
{
  "keywords": [
    "nintendo switch oled"
  ],
  "mode": "active",
  "marketplace": "ebay.com",
  "maxItemsPerSearch": 50,
  "conditions": [],
  "listingType": "all",
  "freeShippingOnly": false,
  "sort": "auto",
  "onlyNew": false,
  "alertOnPriceDrop": false,
  "stateKey": "default",
  "dedupeAcrossSearches": true,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "residentialFallback": true,
  "debugMode": false
}
```

# Actor output Schema

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

One row per eBay listing.

## `summary` (type: `string`):

Count, min, p25, median, average, p75 and max price (and price + shipping) for each search, plus run statistics.

## `errors` (type: `string`):

Searches or pages that could not be read (for example sign-in required for sold listings). Only present when something failed.

# 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 = {
    "keywords": [
        "nintendo switch oled"
    ],
    "mode": "active",
    "maxItemsPerSearch": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("groupoject/ebay-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 = {
    "keywords": ["nintendo switch oled"],
    "mode": "active",
    "maxItemsPerSearch": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("groupoject/ebay-scraper").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 '{
  "keywords": [
    "nintendo switch oled"
  ],
  "mode": "active",
  "maxItemsPerSearch": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call groupoject/ebay-scraper --silent --output-dataset

```

## MCP server setup

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

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/wzu2pH8yb24rGJwol/builds/LH79BVA0D1fnxHTFa/openapi.json