# eBay Seller Feedback Scraper (`automation-lab/ebay-seller-feedback-scraper`) Actor

Export public eBay seller reviews with ratings, comments, buyer scores, item links, verified purchases, and reputation summaries. Schedule monitoring or export JSON, CSV, and Excel — no eBay login required.

- **URL**: https://apify.com/automation-lab/ebay-seller-feedback-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/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 Seller Feedback Scraper** exports public feedback received by eBay sellers.
Give it seller usernames or feedback-profile URLs and get comments, ratings, buyer context,
item links, verified-purchase markers, and seller reputation summaries in structured data.
No eBay login or API key is required.

### What does eBay Seller Feedback Scraper do?

This Actor turns public eBay feedback profiles into analysis-ready records.
It follows feedback pagination and emits one dataset row for every review received as a seller.

Use it to:

- 💬 collect full public feedback comments
- ➕ distinguish positive, neutral, and negative feedback
- 👤 capture public masked buyer names and feedback scores
- 📦 connect feedback to an item title, item ID, and listing URL when eBay exposes them
- ✅ identify verified purchases
- 📊 preserve seller score, positive percentage, and recent rating totals
- 🌍 request profiles through eight supported eBay locales

Unlike a product or inventory scraper, this Actor is designed around **seller reputation history**.

### Who is it for? eBay feedback scraper users

**Marketplace sellers**

- Monitor new feedback about your own stores.
- Route negative comments to customer-support workflows.
- Export a review archive for internal reporting.

**Ecommerce agencies**

- Track reputation for several managed seller accounts.
- Build monthly client reports in Sheets or a BI tool.
- Schedule recurring feedback checks without maintaining scraping infrastructure.

**Competitor-intelligence teams**

- Compare recurring complaints across competing sellers.
- Identify product, delivery, packaging, and support patterns.
- Review public transaction evidence before partnership decisions.

**Trust, safety, and procurement teams**

- Add public reputation evidence to seller due diligence.
- Investigate feedback tied to specific public item pages.
- Preserve source URLs and scrape timestamps for auditability.

### Why use this Actor?

- **No account needed:** it reads public eBay feedback profiles only.
- **Review-level detail:** output is one row per feedback record, not only an aggregate score.
- **Multiple input styles:** use usernames, seller URLs, desktop feedback URLs, or mobile profile URLs.
- **International:** select eBay US, UK, Germany, Australia, Canada, France, Italy, or Spain.
- **Safe failures:** eBay challenge pages produce a clear error instead of a misleading empty dataset.
- **Low overhead:** server-rendered HTML is parsed with HTTP rather than a full browser.
- **Apify-native:** schedule runs, use webhooks, call the API, or export JSON, CSV, Excel, XML, and RSS.

### What eBay seller feedback data can you extract?

| Category | Fields |
|---|---|
| Seller | `sellerUsername`, `sellerProfileUrl` |
| Feedback | `feedbackType`, `comment`, `feedbackAge` |
| Buyer | `buyerUsername`, `buyerFeedbackScore` |
| Item | `itemTitle`, `itemUrl`, `itemId`, `transactionPrice` |
| Verification | `verifiedPurchase` |
| Seller summary | score, positive %, 1/6/12-month counts, member since, country, account flags |
| Provenance | `sourceUrl`, `scrapedAt` |

Some item and buyer fields are optional because eBay does not expose them for every historical record.
The Actor does not guess missing values.

### How much does it cost to scrape eBay seller feedback?

The Actor uses **pay-per-event** pricing.
A small start charge covers initialization, followed by a charge for each saved feedback record.
All Apify platform costs are included.

| Plan tier | Price per feedback record |
|---|---:|
| Free | $0.0002757 |
| Starter / Bronze | $0.00023974 |
| Scale / Silver | $0.000187 |
| Business / Gold | $0.00014385 |
| Platinum | $0.000095897 |
| Diamond | $0.000067128 |

At the Free-tier rate, 1,000 feedback records cost about **$0.27**, plus the small run-start charge.
Higher Apify plans receive volume discounts automatically.
Always begin with 25 records to validate your profile and workflow.

### How to scrape eBay seller reviews

1. Open [eBay Seller Feedback Scraper](https://apify.com/automation-lab/ebay-seller-feedback-scraper).
2. Add one or more seller usernames or feedback-profile URLs.
3. Select the matching eBay locale.
4. Optionally choose a rating, relative age, and sort order.
5. Set a low maximum for your first run.
6. Click **Start**.
7. Preview the dataset and export it as JSON, CSV, Excel, XML, or RSS.

A minimal input is:

```json
{
  "sellers": ["musicmagpie"],
  "locale": "com",
  "maxReviews": 25
}
````

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---:|---|
| `sellers` | string\[] | example seller | Usernames or eBay seller/profile URLs |
| `locale` | string | `com` | eBay domain used for public profile requests |
| `rating` | string | `all` | All, positive, neutral, or negative |
| `period` | string | `all` | All, past month, past six months, or past year |
| `sort` | string | `time` | Newest first or eBay relevance |
| `maxReviews` | integer | `25` | Maximum records across all sellers |
| `proxyConfiguration` | object | residential proxy | Apify or custom proxy settings |

The combined `maxReviews` limit applies across the entire run.
Duplicate usernames and URL aliases are normalized before requests begin.

### Input examples

**Monitor recent negative feedback**

```json
{
  "sellers": ["musicmagpie"],
  "locale": "co.uk",
  "rating": "negative",
  "period": "past-year",
  "sort": "time",
  "maxReviews": 100
}
```

**Compare several sellers**

```json
{
  "sellers": [
    "https://www.ebay.com/fdbk/feedback_profile/musicmagpie",
    "worldofbooks08"
  ],
  "locale": "com",
  "maxReviews": 250
}
```

**Enable Apify Proxy after a network challenge**

```json
{
  "sellers": ["musicmagpie"],
  "maxReviews": 25,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### Output example

```json
{
  "sellerUsername": "musicmagpie",
  "sellerProfileUrl": "https://www.ebay.com/fdbk/feedback_profile/musicmagpie",
  "feedbackType": "positive",
  "comment": "Very good service. Excellent price and the item was as described.",
  "feedbackAge": "Past month",
  "buyerUsername": "o***5",
  "buyerFeedbackScore": 228,
  "itemTitle": "Example album CD",
  "itemUrl": "https://www.ebay.com/itm/302955198391",
  "itemId": "302955198391",
  "transactionPrice": "GBP 15.66",
  "verifiedPurchase": true,
  "sellerSummary": {
    "feedbackScore": 13892120,
    "positivePercent": 99.1,
    "memberSince": "Feb-02-11",
    "country": "United Kingdom",
    "isIdVerified": true,
    "hasEbayStore": true,
    "isBusinessSeller": true,
    "isTopRatedSeller": true
  },
  "sourceUrl": "https://www.ebay.com/fdbk/feedback_profile/musicmagpie?...",
  "scrapedAt": "2026-07-14T05:00:00.000Z"
}
```

### Understanding dates and buyer names

Feedback profiles often expose a relative label such as `Past month` or `Past 6 months`,
not a precise calendar date.
The Actor returns that public label as `feedbackAge` and does not invent an exact timestamp.

Likewise, eBay may mask a buyer name as `o***5`.
The Actor preserves the public form and never attempts to deanonymize buyers.

### Tips for best results

- Start with one seller and `maxReviews: 25`.
- Match `locale` to the seller's primary marketplace when possible.
- Use newest-first sorting for monitoring workflows.
- Schedule a run and deduplicate downstream using seller, item ID, buyer, and comment.
- Keep the default residential proxy for reliable scheduled runs; use direct access only if your network is already trusted by eBay.
- Keep concurrency conservative; the Actor intentionally processes public pages sequentially.
- Remember that old feedback may no longer include a live item URL.

### Scheduling seller reputation monitoring

Apify schedules can run this Actor hourly, daily, weekly, or on a custom cron expression.
For a negative-feedback alert:

1. Set `rating` to `negative`.
2. Set `sort` to `time`.
3. Choose a modest maximum.
4. Schedule the Actor daily.
5. Send the dataset to a webhook, Slack workflow, or automation platform.
6. Deduplicate against records from the previous run.

This creates a practical eBay seller review monitor without maintaining a server.

### Integrations

**eBay feedback → Google Sheets**

Append review rows to a shared seller-quality dashboard.
Use seller username and feedback type for pivots and trend charts.

**eBay feedback → Slack or Discord**

Send new negative comments to a support or trust channel.
Include the public item URL for quick investigation.

**eBay feedback → Make or Zapier**

Trigger a case when a verified negative purchase appears.
Route high-value sellers to a CRM or due-diligence queue.

**eBay feedback → data warehouse**

Schedule exports to S3, BigQuery, Snowflake, or another destination through Apify integrations and webhooks.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ebay-seller-feedback-scraper').call({
  sellers: ['musicmagpie'],
  locale: 'com',
  maxReviews: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Using the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/ebay-seller-feedback-scraper').call(run_input={
    'sellers': ['musicmagpie'],
    'locale': 'com',
    'maxReviews': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Using the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~ebay-seller-feedback-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"sellers":["musicmagpie"],"locale":"com","maxReviews":25}'
```

Read the resulting dataset through the run's `defaultDatasetId`.

### Use with AI agents via MCP

This Actor can be called by AI assistants through the
[Apify Model Context Protocol integration](https://docs.apify.com/platform/integrations/mcp).
You can also open the [actor-scoped MCP endpoint](https://mcp.apify.com?tools=automation-lab/ebay-seller-feedback-scraper) to target this scraper directly.

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```

For Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com"
    }
  }
}
```

Example prompts:

- “Use `automation-lab/ebay-seller-feedback-scraper` to export the latest 50 reviews for musicmagpie.”
- “Collect negative eBay feedback from these three sellers and summarize recurring delivery complaints.”
- “Compare verified-purchase comments and seller reputation summaries for these competitor profiles.”

Your assistant will ask you to authenticate with Apify when required.

### Error handling and anti-bot behavior

Ebay occasionally serves a SplashUI challenge based on network reputation or request volume.
The Actor detects challenge URLs and HTML, retries with backoff, and uses a sticky residential proxy session by default.

It never treats a challenge page as a valid zero-result profile.
A genuine seller with zero public feedback can return an empty dataset successfully;
an unrecognized response throws an actionable error.

### Legality: is it legal to scrape eBay seller feedback?

This Actor extracts information displayed publicly on eBay feedback pages.
Scraping public data is generally legal in many jurisdictions, but how you use it matters.
Follow eBay's terms, applicable copyright and database rules, privacy law, and local regulations.
Do not use public buyer masks to attempt re-identification, harassment, discrimination, or spam.

You are responsible for ensuring your use case is lawful and ethical.
Collect only what you need, secure exports, and honor deletion or access obligations that apply to you.

### FAQ

**Do I need an eBay account or API key?**

No. The Actor uses public feedback-profile pages and does not access orders, messages, or dashboards.

**How fast is it?**

A 25-record profile page usually takes a few seconds.
Larger jobs take longer because requests are deliberately sequential and include polite delays.

**Why are some item fields missing?**

Ebay does not expose item links and prices for every historical feedback record.
Optional fields are omitted rather than guessed.

**Why did my run report a CAPTCHA challenge?**

Your current exit network was challenged by eBay.
Retry later, select the seller's local eBay domain, or keep the default residential Apify Proxy enabled.

**Why is a negative-feedback filter returning few records?**

The selected seller may have few negative reviews in the pages eBay exposes.
Increase `maxReviews` and use newest-first sorting for a broader scan.

**Does the Actor return exact review dates?**

Only when eBay exposes them. The current public profile commonly shows relative age labels,
so the Actor returns `feedbackAge` without fabricating a calendar date.

**How is this different from an eBay product scraper?**

Product scrapers extract listings, prices, or inventory.
This Actor extracts seller reputation records and public review context.

**Can I export to Excel?**

Yes. Open the dataset after a run and choose Excel, CSV, JSON, XML, or RSS.

### Related ecommerce scrapers

- [eBay Scraper](https://apify.com/automation-lab/ebay-scraper) — search and listing data
- [eBay Sold Listings Scraper](https://apify.com/automation-lab/ebay-sold-scraper) — sold-price comparables
- [eBay Seller Scraper](https://apify.com/automation-lab/ebay-seller-scraper) — seller inventory and profile data
- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper) — Amazon product reviews
- [Etsy Shop Reviews Scraper](https://apify.com/automation-lab/etsy-shop-reviews-scraper) — Etsy seller reviews

### Support

If a public profile works in your browser but the Actor cannot parse it,
open an issue from the Actor page and include:

- the public seller username or profile URL
- the selected locale
- the run ID
- whether proxy use was enabled
- the approximate time of the failure

Do not include eBay passwords, cookies, private messages, or order details.

# Actor input Schema

## `sellers` (type: `array`):

Enter eBay usernames, /usr/ URLs, or /fdbk/feedback\_profile/ URLs.

## `locale` (type: `string`):

Domain used to request the public feedback profile.

## `rating` (type: `string`):

Keep all, positive, neutral, or negative seller feedback records.

## `period` (type: `string`):

Filter using the relative age label eBay exposes publicly.

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

Request eBay's newest-first or relevance ordering.

## `maxReviews` (type: `integer`):

Maximum number of records across all sellers. Start small, then scale up.

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

Residential Apify Proxy is enabled by default for reliable public eBay access. Advanced users can supply another proxy configuration.

## Actor input object example

```json
{
  "sellers": [
    "musicmagpie"
  ],
  "locale": "com",
  "rating": "all",
  "period": "all",
  "sort": "time",
  "maxReviews": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "sellers": [
        "musicmagpie"
    ],
    "locale": "com",
    "rating": "all",
    "period": "all",
    "sort": "time",
    "maxReviews": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ebay-seller-feedback-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 = {
    "sellers": ["musicmagpie"],
    "locale": "com",
    "rating": "all",
    "period": "all",
    "sort": "time",
    "maxReviews": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ebay-seller-feedback-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 '{
  "sellers": [
    "musicmagpie"
  ],
  "locale": "com",
  "rating": "all",
  "period": "all",
  "sort": "time",
  "maxReviews": 20
}' |
apify call automation-lab/ebay-seller-feedback-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Seller Feedback Scraper",
        "description": "Export public eBay seller reviews with ratings, comments, buyer scores, item links, verified purchases, and reputation summaries. Schedule monitoring or export JSON, CSV, and Excel — no eBay login required.",
        "version": "0.1",
        "x-build-id": "hPR2YccZ9IVVMcFRh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ebay-seller-feedback-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ebay-seller-feedback-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/automation-lab~ebay-seller-feedback-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ebay-seller-feedback-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/automation-lab~ebay-seller-feedback-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ebay-seller-feedback-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "sellers": {
                        "title": "Seller usernames or profile URLs",
                        "type": "array",
                        "description": "Enter eBay usernames, /usr/ URLs, or /fdbk/feedback_profile/ URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locale": {
                        "title": "eBay locale",
                        "enum": [
                            "com",
                            "co.uk",
                            "de",
                            "com.au",
                            "ca",
                            "fr",
                            "it",
                            "es"
                        ],
                        "type": "string",
                        "description": "Domain used to request the public feedback profile.",
                        "default": "com"
                    },
                    "rating": {
                        "title": "Feedback rating",
                        "enum": [
                            "all",
                            "positive",
                            "neutral",
                            "negative"
                        ],
                        "type": "string",
                        "description": "Keep all, positive, neutral, or negative seller feedback records.",
                        "default": "all"
                    },
                    "period": {
                        "title": "Feedback age",
                        "enum": [
                            "all",
                            "past-month",
                            "past-six-months",
                            "past-year"
                        ],
                        "type": "string",
                        "description": "Filter using the relative age label eBay exposes publicly.",
                        "default": "all"
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "time",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Request eBay's newest-first or relevance ordering.",
                        "default": "time"
                    },
                    "maxReviews": {
                        "title": "Maximum feedback records",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of records across all sellers. Start small, then scale up.",
                        "default": 25
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential Apify Proxy is enabled by default for reliable public eBay access. Advanced users can supply another proxy configuration.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```