# Global Price Arbitrage: Cross-Border Deal Finder (`zaden/my-actor`) Actor

Compare a product's price across Amazon and eBay in the US, UK, Germany, Canada, and Australia, convert to one currency, and see the real landed cost after shipping and import duty — not just the listed price. Includes price-drop monitoring and an AI buy verdict.

- **URL**: https://apify.com/zaden/my-actor.md
- **Developed by:** [Zaden](https://apify.com/zaden) (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 $50.00 / 1,000 query compareds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Global Price Arbitrage — Cross-Border Price Comparison & Landed Cost Calculator

Most price comparison tools tell you a product is "$20 cheaper on the UK site" and stop there. This Actor keeps going: it searches Amazon and eBay across US, UK, Germany, Canada, and Australia storefronts, converts every price to one currency using live exchange rates, and then adds an **estimated landed cost** — shipping plus import duty — so you see what the product actually costs once it reaches you, not just the sticker price on a foreign page.

That's the gap this Actor fills. Plenty of Actors compare domestic retailers (Amazon vs. Walmart vs. Target). None of them tell you whether it's actually cheaper to import the same product from a different country once shipping and duty are accounted for — a price that looks 15% cheaper abroad is often not cheaper at all after those costs, and this Actor is the one that does that math for you.

### What you get, per product

- **Multi-region search** — the same product searched across Amazon and eBay's US, UK, Germany, Canada, and Australia storefronts (you choose which), crawled with bounded concurrency you control.
- **Live currency conversion** — every price normalized into one currency of your choice, using live exchange rates (with an approximate fallback if the rate feed is briefly unavailable, clearly flagged).
- **Landed cost estimate** — item price + an estimated shipping cost + an estimated import duty/tax for every non-domestic marketplace, so cross-border options are ranked on what they'd really cost you, not just the listed price.
- **Ranked comparison table** — the cheapest listing from each marketplace, ranked by landed cost, so the actual best deal is obvious at a glance.
- **A data-confidence grade (A+ to F)** — scraped marketplace pages sometimes block or return nothing; this tells you what fraction of your selected marketplaces actually returned data, so you know how much to trust the ranking, not just whether the run "succeeded."
- **A severity tag** — `critical` (no marketplace returned any data), `warning` (some marketplaces returned data but not all — the ranking may be missing a cheaper option), or `ok` (every selected marketplace returned data) — for instant triage.
- **A one-line executive summary** — the best price found, in plain English, folding in any price-drop alert and data-confidence caveat.
- **Price-drop monitoring (optional)** — the Actor remembers the best option from your last check and flags it when the best deal changes or the price moves, pushed to Slack or your own webhook.
- **AI-written buy verdict (optional, bring your own key)** — paste your own Anthropic or OpenAI API key and get one plain-English sentence recommending where to buy and how much you'd save, instead of just reading a table.

### Why this instead of checking manually

| | Manual tab-checking | Global Price Arbitrage |
|---|---|---|
| Coverage | Whichever storefronts you remember to open | Every marketplace you select, automatically |
| Math | You eyeball the sticker price | Live FX conversion + landed cost (shipping + duty) per option |
| Trust signal | You just hope the page loaded right | Explicit data-confidence grade and severity per query |
| Repeatability | Re-checking is manual, tedious | One click, or schedule it with price-drop alerts |
| Output | Browser tabs and mental math | Structured dataset, exportable to CSV/JSON/BI tools |

### Who this is for

- Shoppers comparing a specific product across countries before an expensive purchase (electronics, cameras, watches, collectibles)
- Resellers and arbitrage sellers checking whether cross-border sourcing is actually profitable after shipping and duty
- Anyone who's seen "it's cheaper on Amazon UK" and wants to know if that's still true once it lands in their country
- Deal-hunters who want price-drop alerts on a specific product across multiple regions, not just one

### How to use it

1. Add one or more **products to compare** (product name or search term).
2. Pick which **marketplaces to check** — more marketplaces means a more complete comparison but a longer run.
3. Set the **currency** you want prices compared in and your **destination country** (this determines which marketplaces count as domestic vs. cross-border).
4. Optionally override the built-in **shipping estimate** or set an **import duty percentage** if you know your category's typical rate.
5. Optionally paste a **Slack/webhook URL** to get alerted when the best deal changes, and/or your own **Anthropic or OpenAI API key** for a written buy verdict.
6. Optionally adjust **max concurrent marketplace requests** — the default (3) is deliberately conservative since Amazon and eBay block aggressively; raise it if you're on residential proxies and want faster runs.
7. Run it once for a snapshot, or put it on an Apify **Schedule** to track a product's best cross-border price over time.

### Example output (one item)

```json
{
  "query": "Sony WH-1000XM5 headphones",
  "targetCurrency": "USD",
  "destinationCountry": "US",
  "fxRatesLive": true,
  "grade": "A+",
  "dataConfidence": 100,
  "severity": "ok",
  "summary": "Best price: Amazon Germany at 291.40 USD -- Best deal on Amazon Germany dropped, 299.10 -> 291.40 USD (-2.6%). (5/5 marketplaces returned data.)",
  "successfulMarketplaces": 5,
  "totalMarketplaces": 5,
  "bestOption": {
    "marketplace": "amazon_de",
    "marketplaceLabel": "Amazon Germany",
    "title": "Sony WH-1000XM5 Wireless Headphones",
    "url": "https://www.amazon.de/...",
    "itemPrice": 279.40,
    "estimatedShipping": 12,
    "estimatedDuty": 0,
    "landedCostEstimate": 291.40,
    "currency": "USD",
    "isDomestic": false
  },
  "ranked": [
    { "marketplaceLabel": "Amazon Germany", "landedCostEstimate": 291.40 },
    { "marketplaceLabel": "Amazon US", "landedCostEstimate": 329.99 },
    { "marketplaceLabel": "eBay US", "landedCostEstimate": 341.50 }
  ],
  "diffSummary": "Best deal on Amazon Germany dropped, 299.10 -> 291.40 USD (-2.6%).",
  "aiVerdict": "Buy from Amazon Germany — landed cost of $291 beats the US price by about 12% even after estimated shipping."
}
```

### Pricing

This Actor uses pay-per-event pricing:

- **Query compared** — charged once per product query processed, regardless of how many marketplaces were searched (all marketplace scraping, currency conversion, and landed cost calculation is bundled into this one event).
- **AI verdict** — charged only when you've supplied your own API key and a verdict was successfully produced. No key, no charge.

Note: AI verdicts require your own Anthropic or OpenAI API key, and that provider bills you directly for the underlying LLM call — this Actor's "AI verdict" event only covers the orchestration. Residential proxy is used by default for reliable results — Amazon and eBay rate-limit or block non-residential IPs quickly — with automatic retries and session rotation if a marketplace serves a block/captcha page. Marketplace requests run with bounded concurrency (default 3, configurable) rather than one at a time, so multi-marketplace runs finish faster without hammering any single storefront.

### FAQ

**What do the "grade," "severity," and "data confidence" fields mean?**
Marketplace scraping isn't guaranteed to work every time — a storefront can block a request, change its markup, or return an empty page. Rather than silently ranking whatever came back, this Actor tells you how complete the picture is: `dataConfidence` is the percent of your selected marketplaces that returned at least one listing, `grade` turns that into a letter (A+ to F), and `severity` is `critical` if nothing came back at all, `warning` if some but not all marketplaces returned data (the ranking may be missing a cheaper option), or `ok` if every marketplace responded.

**How accurate is the landed cost estimate?**
It's a planning estimate, not a customs broker's calculation. Shipping is a flat estimate you can override; duty is a simple percentage you set (default 0%, since actual rates depend on product category, your country's de minimis threshold, and personal exemptions). Use it to compare options directionally — always confirm the real total at checkout before buying internationally.

**Why do the same marketplace searches sometimes return different products?**
Search results are matched by keyword like a normal shopper would search, not by a universal product ID. For best results, search with a specific model name/number rather than a generic description.

**Does this add anything to a cart or place an order?**
No. This Actor only reads public search results pages — no login, no cart, no checkout. It's read-only, the same way a human browsing and comparing tabs would be.

**Does price monitoring work across scheduled runs?**
Yes — the best-option baseline is stored in your own Apify account (a persistent key-value store), keyed by product + currency + destination + marketplace selection, so it persists between runs regardless of how you trigger them.

**How does the AI buy verdict work, and is my API key safe?**
Paste your own Anthropic or OpenAI API key and pick the matching provider. The Actor sends the ranked landed-cost table (numbers only, no personal data) to your provider with a tight prompt asking for one recommendation sentence. Your key is read from that run's input, used for that one HTTP request, and discarded — never logged, stored, or reused across runs. If you leave this blank, everything else works the same, you just read the ranked table yourself instead of a one-sentence verdict.

**Is this legal?**
Reading publicly available product listing pages is generally legal; this Actor does not create accounts, log in, or interact with any site beyond searching and reading. Import duty and customs rules vary by country and change over time — this tool's duty estimate is not legal, tax, or customs advice, and you're responsible for verifying actual costs before making a cross-border purchase.

# Actor input Schema

## `productQueries` (type: `array`):

One or more product names or search terms to look up across marketplaces (e.g. "Sony WH-1000XM5"). Each is searched independently on every selected marketplace.

## `marketplaces` (type: `array`):

Which country storefronts to search. More marketplaces means a more complete comparison but a longer, more expensive run.

## `targetCurrency` (type: `string`):

All prices are converted to this currency (live exchange rates) so they can be ranked side by side.

## `destinationCountry` (type: `string`):

Used to decide which marketplaces count as "domestic" (no shipping/duty estimate added) versus "cross-border" (shipping + duty estimate added).

## `maxResultsPerMarketplace` (type: `integer`):

How many search results to pull from each marketplace per product. The cheapest one from each marketplace is used for ranking.

## `shippingEstimateOverride` (type: `integer`):

Flat shipping cost estimate, in your target currency, applied to non-domestic marketplaces. Leave blank to use a built-in default (~$12-15 equivalent).

## `dutyEstimatePercent` (type: `integer`):

Rough percentage of item price to add as an estimated customs duty/import tax for non-domestic marketplaces. This is a planning estimate only — actual duty depends on product category and destination country rules. Set to 0 to ignore duty entirely.

## `detectChanges` (type: `boolean`):

Compare this run's best landed-cost option against the last time you checked the same product (stored in your account). Most useful when this Actor is run on a schedule.

## `webhookUrl` (type: `string`):

If set, this Actor POSTs a JSON alert here whenever the best landed-cost option changes or moves to a different marketplace. Works directly with Slack incoming webhooks. Leave blank to disable.

## `aiApiKey` (type: `string`):

Paste your own Anthropic or OpenAI API key to get a one-sentence recommendation on where to buy and how much you'd save, instead of just a ranked table. Your key is used only for this run and never stored. Billed as a separate event, only when a verdict is actually produced.

## `aiProvider` (type: `string`):

Which provider your API key above is for. Only used if you supplied a key.

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

How many marketplace search pages to crawl in parallel. Amazon and eBay rate-limit and block aggressively, so this defaults conservatively -- raise it only if you're using residential proxies and want faster runs, and lower it if you see more blocked/empty results.

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

Amazon and eBay rate-limit or block non-residential IPs quickly, so this defaults to residential proxy for reliable results. You can switch to datacenter proxy to reduce cost, at the risk of more blocked/empty marketplace results.

## Actor input object example

```json
{
  "productQueries": [
    "Sony WH-1000XM5 headphones"
  ],
  "marketplaces": [
    "amazon_us",
    "amazon_uk",
    "amazon_de",
    "ebay_us",
    "ebay_uk"
  ],
  "targetCurrency": "USD",
  "destinationCountry": "US",
  "maxResultsPerMarketplace": 5,
  "dutyEstimatePercent": 0,
  "detectChanges": true,
  "aiProvider": "anthropic",
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "productQueries": [
        "Sony WH-1000XM5 headphones"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zaden/my-actor").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 = { "productQueries": ["Sony WH-1000XM5 headphones"] }

# Run the Actor and wait for it to finish
run = client.actor("zaden/my-actor").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 '{
  "productQueries": [
    "Sony WH-1000XM5 headphones"
  ]
}' |
apify call zaden/my-actor --silent --output-dataset

```

## MCP server setup

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

```

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/Fao34fM5kEERMlY3I/builds/SCUmyFhJCdMKacAFl/openapi.json