# eBay Arbitrage & Sold Comps Deal Radar (`xr3less/ebay-arbitrage-deal-radar`) Actor

Real-time eBay retail arbitrage radar comparing active Buy-It-Now listings against historical sold comps to identify profitable arbitrage deals.

- **URL**: https://apify.com/xr3less/ebay-arbitrage-deal-radar.md
- **Developed by:** [Furkan Güler](https://apify.com/xr3less) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Arbitrage & Deal Radar — Real-Time Sold Comps, Price Drops & Webhook Alerts

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-orange.svg)](https://apify.com/store)
[![Pay-Per-Event](https://img.shields.io/badge/Pricing-Pay--Per--Event-green.svg)](#pricing--cost-efficiency)
[![MCP Compatible](https://img.shields.io/badge/MCP-Compatible-blue.svg)](#autonomous-ai-agents--mcp-integration)
[![x402 Micropayments](https://img.shields.io/badge/Payments-x402%20Base%20USDC-purple.svg)](#autonomous-ai-agents--mcp-integration)
[![Global Marketplaces](https://img.shields.io/badge/eBay-Global%20Marketplaces-yellow.svg)](#supported-ebay-marketplaces)
[![TypeScript](https://img.shields.io/badge/Runtime-Node.js%20%2F%20TypeScript-blue.svg)](#technical-architecture)

***

### Executive Summary: Stop Dumping Raw Listings, Start Finding Real Arbitrage

Most eBay scrapers on the market do one thing: they dump thousands of raw, unprocessed active search listings into a CSV file. They leave you with the hardest parts of the job:

- You still have to manually check completed and sold listings to figure out what items actually sell for.
- You still have to open a calculator and deduct eBay final value fees, category charges, and shipping rates.
- You still have to keep running searches manually to notice when a seller drops their price.
- You still have to build custom infrastructure to alert your team when a true mispriced deal appears.

**eBay Arbitrage & Deal Radar** is an intelligent, real-time market scanner and valuation engine built specifically for:

- Professional resellers and retail arbitrage operators
- Trading card (TCG, Pokemon, Sports) and collectible flippers
- E-commerce brands monitoring grey-market inventory and pricing
- Automated sniper bots and high-frequency purchasing pipelines
- Autonomous AI agents operating via Model Context Protocol (MCP) and x402 Base USDC micropayments

#### The Unfair Advantage: Automated Fair Market Value & Net Profit Engine

Unlike generic scrapers, this Actor does not merely collect asking prices. For every target keyword or category, it:

1. Scrapes active **Buy It Now** listings across your chosen regional eBay marketplace.
2. Simultaneously queries historical **completed and realized sold comps** to calculate an empirical **Fair Market Value (FMV)**.
3. Automatically deducts **eBay final value fees (standard 13.25% + $0.30 fixed fee)** and shipping overhead from the median comp.
4. Calculates your exact **estimated net profit** (`estimatedNetProfit`) and **net ROI margin percentage** (`dealMarginPercent`).
5. Tracks price history across runs using persistent Key-Value store state to detect **seller price drops**.
6. Instantly dispatches rich embed alerts with photos and buy links to **Discord**, **Telegram**, or **custom webhooks** (Make, n8n, Zapier).

***

### Key Features & Architectural Differentiators

| Feature | Generic eBay Scrapers | eBay Arbitrage & Deal Radar |
| :--- | :--- | :--- |
| **Data Output** | Raw titles and asking prices only | Enriched valuation, Fair Market Value, and Net Profit margins |
| **Sold Comps Analysis** | Not available (or requires separate scraper) | Integrated automatic historical sold comps computation |
| **Fee Deduction** | Manual spreadsheet calculation required | Automatic deduction of 13.25% eBay fees + shipping |
| **Stateful Memory** | Stateless (duplicates data every run) | Persistent Key-Value store memory tracks price drops run-over-run |
| **Alerting** | None (requires external glue code) | Native Discord rich embeds, Telegram messages, and JSON webhooks |
| **Scraping Engine** | Heavy Chrome browsers (2GB+ RAM, slow) | Lightweight browser TLS fingerprint client (<256MB RAM, fast) |
| **Billing Model** | High flat fees ($1.80 to $25.00 per 1k items) | Micro Pay-Per-Event ($0.0008/item scanned, $0.005/alert) |
| **AI Agent Support** | Proprietary API keys only | Native MCP endpoint and x402 Base USDC payment support |

#### 1. 17 Regional eBay Marketplaces Supported

Scrape and evaluate listings in native currencies across North America, Europe, and Asia-Pacific:

- `com` — United States (USD)
- `co.uk` — United Kingdom (GBP)
- `de` — Germany (EUR)
- `ca` — Canada (CAD)
- `com.au` — Australia (AUD)
- `fr` — France (EUR)
- `it` — Italy (EUR)
- `es` — Spain (EUR)
- Additional regional support includes Netherlands (`nl`), Ireland (`ie`), Switzerland (`ch`), Austria (`at`), Belgium (`be`), Poland (`pl`), and more.

#### 2. Real-Time Arbitrage Engine

Filter out noise and focus purely on high-margin inventory. Set thresholds such as:

- **`minProfitUsd`**: Only flag listings with at least $15 (or custom threshold) in net profit after all fees.
- **`minMarginPercent`**: Require a minimum net return on investment (e.g. 20% ROI over total acquisition cost).

#### 3. Delta Price Drop & New Listing Tracking

When running on an automated schedule (e.g., every 15 minutes), the Actor uses Apify Key-Value Store persistence (`EBAY_PRICE_STATE`):

- Detects when a seller slashes an asking price and calculates `priceDelta`.
- Flags newly posted listings with `isNewListing: true`.
- In **Monitor Mode** (`monitorMode: true`), only newly discovered listings, price drops, or qualifying deals are saved and alerted, eliminating duplicate data clutter and saving billing credits.

#### 4. Zero-Waste Pay-Per-Event Billing

You are never charged high fixed subscription rates. The Actor charges micropayments strictly per item scanned ($0.0008) and per deal alert generated ($0.005).

***

### Input Configuration

The Actor accepts structured search parameters, regional preferences, profit thresholds, and notification endpoints.

#### Input Parameters

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `queries` | Array of Strings | Required | Target search queries, product names, or direct eBay search URLs. |
| `marketplace` | String | `"com"` | Regional eBay marketplace (`com`, `co.uk`, `de`, `ca`, `com.au`, `fr`, `it`, `es`). |
| `maxItemsPerQuery` | Integer | `60` | Maximum active listings to extract per query (range: 10 to 300). |
| `includeSoldComps` | Boolean | `true` | Scrapes completed and sold listings to compute Fair Market Value. |
| `minProfitUsd` | Number | `15.0` | Minimum estimated net profit in USD after eBay fees (13.25% + $0.30). |
| `minMarginPercent` | Number | `20.0` | Minimum net profit margin percentage required to flag as a deal. |
| `monitorMode` | Boolean | `false` | If enabled, only records new listings, price drops, or qualifying deals. |
| `discordWebhookUrl` | String | `null` | Discord channel webhook URL for instant rich embeds. |
| `telegramBotToken` | String | `null` | Telegram bot token from @BotFather for alert delivery. |
| `telegramChatId` | String | `null` | Target Telegram chat or channel ID. |
| `customWebhookUrl` | String | `null` | Generic HTTP POST endpoint (for Make, n8n, Zapier, or custom backends). |
| `proxyConfiguration` | Object | Residential | Apify Proxy configuration (residential proxies strongly recommended). |

#### Sample Input JSON

```json
{
  "queries": [
    "Charizard Base Set PSA 10",
    "RTX 4080 Super Founders Edition",
    "Omega Seamaster Professional 300M"
  ],
  "marketplace": "com",
  "maxItemsPerQuery": 60,
  "includeSoldComps": true,
  "minProfitUsd": 25.0,
  "minMarginPercent": 15.0,
  "monitorMode": true,
  "discordWebhookUrl": "https://discord.com/api/webhooks/1234567890/abcdefghijklmnopqrstuvwxyz",
  "customWebhookUrl": "https://your-n8n-instance.com/webhook/ebay-deals",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

***

### Output Dataset Schema

Every listing processed by the Actor is emitted as a structured JSON object with full price, seller, valuation, and margin metadata.

#### Sample Output Record

```json
{
  "itemId": "186392019482",
  "title": "Pokemon 1999 Base Set Shadowless Charizard #4/102 PSA 10 GEM MINT",
  "url": "https://www.ebay.com/itm/186392019482",
  "imageUrl": "https://i.ebayimg.com/images/g/abc123xyz/s-l1600.jpg",
  "askingPrice": 2499.00,
  "shippingPrice": 0.00,
  "totalCost": 2499.00,
  "currency": "USD",
  "condition": "Graded - PSA 10",
  "listingType": "BuyItNow",
  "seller": {
    "username": "vintage_vault_collectibles",
    "feedbackScore": 4820,
    "positiveFeedbackPercent": 99.8
  },
  "fairMarketValue": 3450.00,
  "soldCompsCount": 12,
  "estimatedNetProfit": 487.57,
  "dealMarginPercent": 27.57,
  "isDeal": true,
  "priceChanged": true,
  "prevPrice": 2850.00,
  "priceDelta": -351.00,
  "isNewListing": false,
  "discoveredAt": "2026-10-10T03:30:00.000Z"
}
```

#### Field Breakdown

- **`itemId`**: Unique eBay listing identifier.
- **`title`**: Full listing title.
- **`askingPrice`**: Seller's current Buy It Now asking price.
- **`shippingPrice`**: Stated shipping fee (or 0 for free shipping).
- **`totalCost`**: Combined acquisition cost (`askingPrice + shippingPrice`).
- **`fairMarketValue`**: Median realized price from historical sold comps for matching keywords.
- **`soldCompsCount`**: Total number of recent sold listings analyzed.
- **`estimatedNetProfit`**: Net profit after subtracting estimated eBay selling fees (13.25% + $0.30) and acquisition costs.
- **`dealMarginPercent`**: Net discount margin percentage relative to Fair Market Value (`((fairMarketValue - totalCost) / fairMarketValue) * 100`).
- **`isDeal`**: Boolean indicator (`true` if `estimatedNetProfit >= minProfitUsd` and `dealMarginPercent >= minMarginPercent`).
- **`priceChanged`**: `true` if the seller changed their price compared to the previous run.
- **`prevPrice`**: The prior observed asking price from Key-Value store state.
- **`priceDelta`**: Difference between current price and previous price (negative value indicates a price drop).
- **`isNewListing`**: `true` if this listing was observed for the first time in the current run.

***

### Integration Guides

#### 1. Setting Up Discord Alerts

Receive real-time rich embeds whenever a qualifying arbitrage deal or price drop is discovered.

1. Open your Discord server and navigate to the target channel (e.g., `#ebay-deals`).
2. Click **Channel Settings** (the gear icon) -> **Integrations** -> **Webhooks**.
3. Click **New Webhook**, name it "eBay Deal Radar", and click **Copy Webhook URL**.
4. Paste the copied URL into the `discordWebhookUrl` input field of this Actor.
5. When a deal is found, the Actor dispatches a formatted Discord embed featuring:
   - High-resolution product image
   - Asking price and estimated Fair Market Value
   - Calculated net profit and ROI percentage
   - Seller feedback rating
   - Direct link to purchase on eBay

#### 2. Connecting with n8n / Make / Zapier

Automate purchasing workflows, trigger spreadsheet logging, or alert your private sales team:

1. Create a Webhook trigger node in n8n, Make, or Zapier.
2. Select HTTP method `POST` and copy the generated Webhook endpoint URL.
3. Paste the URL into `customWebhookUrl` in the Actor configuration.
4. Each time a deal or price drop occurs, the Actor transmits the full JSON payload with `Content-Type: application/json`.
5. Example downstream actions you can build:
   - Append deal records to a Google Sheet or Airtable base.
   - Send SMS alerts via Twilio for deals exceeding $100 profit.
   - Trigger automated bidding or checkout scripts.

#### 3. Autonomous AI Agents & MCP Integration

This Actor supports direct invocation by autonomous AI agents, LLM tool-calling loops, and multi-agent systems via the **Model Context Protocol (MCP)** and **x402 Base USDC micropayments**.

##### Direct MCP Invocation

Add this Actor as an MCP tool in Claude Desktop, Cursor, or your LangChain/LlamaIndex pipeline using the official Apify MCP gateway:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/mcp-server"],
      "env": {
        "APIFY_TOKEN": "<YOUR_APIFY_TOKEN>"
      }
    }
  }
}
```

Autonomous agents can query real-time market comps and arbitrage opportunities on demand by calling the tool with natural language intent (e.g., *"Find all graded PSA 10 Charizard cards on eBay with at least 20% arbitrage margin"*).

##### x402 Base USDC Micropayments

For agent-to-agent autonomous commerce without credit card lock-in:

- The Actor supports the **x402 standard (HTTP 402 Payment Required)**.
- AI agents with on-chain crypto wallets can pay per event using Base network USDC micropayments directly at execution time.
- No monthly subscriptions, no manual billing setup, and zero human intervention required.

***

### Pricing & Cost Efficiency

This Actor operates under Apify's **Pay-Per-Event (PPE)** model. You only pay for the work performed, aligned directly with the value you receive.

#### Event Pricing Structure

| Event | Rate | Cost per 1,000 Units | Description |
| :--- | :--- | :--- | :--- |
| **Actor Run Start** | $0.001 | $1.00 per 1,000 runs | Base container initialization fee |
| **Item Scanned** | $0.0008 | $0.80 per 1,000 items | Extraction and parsing of active listing |
| **Deal Alert Generated** | $0.005 | $5.00 per 1,000 alerts | Fair Market Value computation and webhook dispatch |

#### Cost Comparison: Why Our Model Wins

| Solution | Cost per 1k Items | Historical Comps? | Net Profit Math? | State & Price Drops? | Real Cost for 10k Items |
| :--- | :--- | :--- | :--- | :--- | :--- |
| **Legacy eBay Scrapers** | $25.00 | No | No | No | $250.00 |
| **Generic Search Scrapers** | $1.80 – $3.45 | No | No | No | $18.00 – $34.50 |
| **eBay Arbitrage & Deal Radar** | **$0.80** | **Yes** | **Yes** | **Yes** | **$8.00 + alerts** |

#### Practical Monthly Cost Scenarios

- **Scenario A: Daily Arbitrage Sweep (Collector / Small Reseller)**
  - Runs once per day scanning 100 items across 5 categories (500 items/day = 15,000 items/month).
  - Finds an average of 5 qualifying deals per day (150 deal alerts/month).
  - Monthly cost: 30 starts ($0.03) + 15,000 scans ($12.00) + 150 alerts ($0.75) = **$12.78 / month**.
- **Scenario B: High-Frequency Deal Radar (Professional Reselling Operation)**
  - Runs every 15 minutes in `monitorMode` tracking high-value electronics and luxury watches.
  - 96 runs/day, scanning 60 items per run.
  - Because `monitorMode` only emits new items and price drops, duplicate dataset writes are suppressed.
  - Total operational cost remains under **$35 to $45 / month** while monitoring round-the-clock for instant flips.

***

### Technical Architecture & Reliability

- **Lightweight Fingerprinted HTTP Engine:** Built using `got-scraping` with modern browser TLS and HTTP/2 fingerprinting. Bypasses standard bot detection without spinning up heavy, resource-intensive Chrome instances.
- **Memory Footprint:** Runs on just 256MB to 512MB RAM, maintaining sub-second per-page execution speed and high concurrency.
- **Resilient Fallback Parsing:** Equipped with multi-layered Cheerio selector fallbacks to handle dynamic eBay HTML layouts and layout updates without failing.
- **Fault-Tolerant Proxying:** Seamlessly integrates with Apify Residential Proxy pools to rotate IPs across target regional geographies.

***

### Frequently Asked Questions

#### Do I need an eBay developer account or API keys?

No. The Actor extracts public search and completed sold listings directly from eBay's regional web interfaces using browser-emulated HTTP requests. No developer application, token refresh, or eBay API approval is needed.

#### How are eBay selling fees calculated?

The Actor applies standard eBay seller fee math: a category final value fee of 13.25% plus a $0.30 fixed transaction fee. This provides an accurate baseline net calculation for general merchandise, electronics, collectibles, and trading cards.

#### What happens if no sold comps are found for a keyword?

If a rare or uniquely titled item has no recent historical sold listings matching its terms, `fairMarketValue` and `estimatedNetProfit` will return `null`. The listing is still captured with its full asking price and seller information so no data is lost.

#### Can I monitor specific eBay categories or filtered search URLs?

Yes. You can pass raw search keywords (e.g. `"RTX 4080 Super"`) or complete eBay search URLs with pre-applied filters (such as condition, item location, price caps, or seller feedback filters) directly in the `queries` array.

***

### Support & Custom Inquiries

For feature requests, enterprise integration assistance, or custom marketplace rules, reach out through the Apify Console Actor discussion tab.

# Actor input Schema

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

Enter search terms or direct eBay search URLs to monitor and evaluate for retail arbitrage opportunities.

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

Target eBay regional marketplace domain.

## `maxItemsPerQuery` (type: `integer`):

Maximum number of active listings to fetch and analyze per query.

## `includeSoldComps` (type: `boolean`):

Scrape completed/sold eBay listings to calculate Fair Market Value (FMV) and net arbitrage margins.

## `minProfitUsd` (type: `number`):

Minimum net profit threshold in USD after deducting eBay seller fees (13.25% + $0.30) and shipping costs.

## `minMarginPercent` (type: `number`):

Minimum net margin percentage (ROI) relative to total acquisition cost to qualify as an arbitrage deal.

## `monitorMode` (type: `boolean`):

If enabled, compares scraped listings against persistent Key-Value Store state and only outputs/alerts on newly discovered items, price changes, or qualifying deals.

## `discordWebhookUrl` (type: `string`):

Discord channel webhook URL to receive instant rich embed notifications when qualifying deals are discovered.

## `telegramBotToken` (type: `string`):

Telegram Bot API token for dispatching deal alert notifications.

## `telegramChatId` (type: `string`):

Telegram chat or channel ID where deal alert messages will be sent.

## `customWebhookUrl` (type: `string`):

Generic HTTP POST webhook URL for external automation workflows (Make, n8n, Zapier, custom API).

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

Apify Proxy configuration. RESIDENTIAL proxy groups are strongly recommended for eBay scraping to ensure high success rates.

## Actor input object example

```json
{
  "queries": [
    "Charizard PSA 10",
    "RTX 4080 Super",
    "Omega Seamaster"
  ],
  "marketplace": "com",
  "maxItemsPerQuery": 60,
  "includeSoldComps": true,
  "minProfitUsd": 15,
  "minMarginPercent": 20,
  "monitorMode": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Full dataset of scraped eBay listings with fair market value, net profit, deal margins, and price deltas.

## `state` (type: `string`):

Key-Value store caching historical prices for delta tracking and deal discovery.

# 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": [
        "Charizard PSA 10",
        "RTX 4080 Super",
        "Omega Seamaster"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("xr3less/ebay-arbitrage-deal-radar").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": [
        "Charizard PSA 10",
        "RTX 4080 Super",
        "Omega Seamaster",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("xr3less/ebay-arbitrage-deal-radar").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": [
    "Charizard PSA 10",
    "RTX 4080 Super",
    "Omega Seamaster"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call xr3less/ebay-arbitrage-deal-radar --silent --output-dataset

```

## MCP server setup

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

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/3jU4VhLIpiEIYanH9/builds/8c9T0uVTY9DP6aPaz/openapi.json