# Price Tracker API (`truefetch/price-tracker-api`) Actor

A product price tracker api that searches 23 country-aware shopping routes and returns 55-field price, stock, seller, rating, rank, and source records through one four-input contract.

- **URL**: https://apify.com/truefetch/price-tracker-api.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.38 / 1,000 results

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

## Price Tracker API

**Price Tracker API is a product price tracker api that searches country-aware shopping routes by keyword and returns observations under a 56-field schema covering product, offer, seller, availability, rank, and source data for developers who want one price-search contract across several retail sites.**

- **Four public inputs, three required:** `keyword`, `country`, and `max_results` are required; `platforms` is optional.
- **33 supported markets and 23 selectable platform values** are stated directly in the input schema.
- **56 public Dataset fields** define the shared row schema for product identity, price, seller, fulfillment, reputation, and provenance; optional properties may be absent or empty.
- **Pay-per-event pricing** charges $0.01000 per Actor Start and one tiered Result event for each stored Dataset row.

[**Run a one-result test**](https://apify.com/truefetch/price-tracker-api) · [**View API**](https://apify.com/truefetch/price-tracker-api/api)

Set `max_results` to `1` and select one platform. At the FREE rate, one stored row costs at most **$0.01850** including Actor Start; an empty Dataset adds no Result event.

### What does Price Tracker API do?

Price Tracker API turns a current keyword search into source-linked product rows that can be exported or consumed through the Apify API. The tested scenario uses `gaming monitor` in `Germany` and requests up to 2 results from `MediaMarkt`. Each accepted row can include identifiers, current and previous price text, discounts, availability, seller context, ratings, fulfillment text, rank, and the originating URL.

[eBay advanced-search guidance](https://www.ebay.com/help/advanced-search/buying/advanced-search?id=4049) shows that marketplace search results depend on keywords, filters, active listings, and the selected market. This independent Actor records source-visible observations; it does not create history, guarantee local stock, place orders, or infer missing values.

### How do I run Price Tracker API?

Run Price Tracker API by supplying the keyword, an allowed country, a positive result limit, and optionally the platform selection.

1. Open the [Input page](https://apify.com/truefetch/price-tracker-api/input) and keep the prefilled tested example or replace `keyword` with the product phrase you need.
2. Choose one of the 33 allowed `country` values. Keep `platforms` empty to use all eligible routes, or select only values allowed by this edition.
3. Set `max_results` to a positive integer. The limit applies per selected platform; there is no artificial 10,000-result schema ceiling.
4. Start the run, then open the default Dataset to inspect, filter, or export the rows.

```json
{
  "keyword": "gaming monitor",
  "country": "Germany",
  "max_results": 2,
  "platforms": [
    "MediaMarkt"
  ]
}
```

This tested profile returned 2 Dataset rows. Live marketplaces may return fewer for narrow queries, removed products, or unavailable routes.

### What data does Price Tracker API return?

Price Tracker API returns one normalized product observation per Dataset row, under a 56-field schema. The fields are grouped below; source-dependent properties may be absent or empty.

| Group | Public fields |
| --- | --- |
| Media | `image_url`, `image_urls` |
| Identity and catalog | `title`, `brand`, `badges`, `category`, `breadcrumbs`, `description`, `features`, `product_id`, `sku`, `gtin`, `mpn`, `model`, `specifications`, `manufacturer`, `origin`, `energy_class`, `included`, `condition`, `release_date`, `variants` |
| Price and promotion | `price`, `was_price`, `unit_price`, `currency`, `price_text`, `discount_pct`, `discount_text`, `promo_text`, `installment_text` |
| Availability and fulfillment | `stock_status`, `stock_text`, `sales_text`, `shipping_text`, `shipping_cost`, `delivery_text`, `pickup_text`, `return_text`, `return_days`, `warranty_text` |
| Reputation and seller | `rating`, `review_count`, `seller`, `seller_url`, `seller_score` |
| Provenance | `platform`, `site`, `country`, `product_url`, `source_url`, `rank`, `is_sponsored`, `processor`, `processed_at` |

This is an abbreviated, illustrative 13-field item from the shared scenario; the effective Dataset schema contains 56 fields, and arrays or unavailable values may be empty:

```json
{
  "title": "ASUS ROG Strix OLED XG27AQDMGR 26,5 Zoll QHD Monitor 0,03 ms Reaktionszeit 240 Hz",
  "brand": "ASUS",
  "price": 479.99,
  "currency": "EUR",
  "stock_status": "",
  "rating": 4.4359,
  "review_count": 39,
  "seller": "",
  "platform": "mediamarkt",
  "country": "DE",
  "rank": 1,
  "is_sponsored": null,
  "processed_at": "2026-08-11T04:04:27+00:00"
}
```

Use `product_id`, `sku`, `gtin`, `mpn`, `model`, and `product_url` for identity checks before deduplicating. `rank` is the collected search position, `is_sponsored` reflects the source signal when present, and `processed_at` records processing time. Export the Dataset as JSON, CSV, Excel, XML, RSS, or another format supported by Apify.

### What inputs can I configure?

Price Tracker API exposes exactly four public inputs in schema order, including three required fields and one optional array.

| Parameter | Type | Required | Description | Tested example |
| --- | --- | --- | --- | --- |
| `keyword` | string | Yes | Product phrase, brand, or model to search across eligible shopping routes. | `"gaming monitor"` |
| `country` | string | Yes | Country used to select eligible marketplace domains and retailer routes across 33 supported markets. | `"Germany"` |
| `max_results` | integer | Yes | Maximum product records returned per selected platform; enter any integer greater than zero. | `2` |
| `platforms` | array | No | Optional subset of 23 shopping sources; leave empty to use every source supported for the selected country. | `["MediaMarkt"]` |

`platforms` remains a real input in fixed editions: choose the edition's singleton value or leave the array empty, which preserves the fixed route. The Actor respects the supplied `keyword`, `country`, and positive `max_results`; it does not silently replace them with unrelated defaults.

### What platforms and markets does Price Tracker API cover?

Price Tracker API covers only the platform and market combinations represented by its effective enums and runtime route map.

The effective schema contains 33 country values: Australia, Austria, Belgium, Brazil, Canada, Chile, Egypt, France, Germany, Hong Kong, Hungary, India, Indonesia, Ireland, Italy, Japan, Luxembourg, Malaysia, Mexico, Netherlands, New Zealand, Poland, Portugal, Saudi Arabia, Singapore, Spain, South Korea, Sweden, Switzerland, Turkey, United Arab Emirates, United Kingdom, United States. The `platforms` input contains 23 values: Amazon, AJIO, AliExpress, eBay, Target, Flipkart, OTTO, Argos, John Lewis, Bol.com, Hepsiburada, Rakuten, Kakaku, Big W, Blibli, JB Hi-Fi, Canadian Tire, MediaMarkt, Walmart, ASOS, Myntra, Nykaa, TradeIndia.

Country selection changes the storefront or regional route where the platform supports it. It does not promise that every product, seller, delivery option, or language is available in every market. When a source shows localized currency, title, shipping, or promotion text, the row preserves that source-facing context.

### Why use Price Tracker API?

Use Price Tracker API when a current, normalized Dataset is more useful than repeatedly copying search cards by hand.

| Capability | Practical benefit |
| --- | --- |
| Keyword-driven search | Reuse a product phrase across scheduled or API-triggered runs. |
| 56-field row contract | Keep downstream columns stable while source coverage varies. |
| Country and platform enums | Reject unsupported market combinations before a run starts. |
| Source URLs and processing time | Trace an observation back to the marketplace and its collection time. |
| Pay per stored result | Estimate row cost before running a bounded test. |

The main trade-off is explicit: it returns current observations, not a hosted history or alert database. Treat rows as current observations, validate important purchasing decisions against the linked source, and design monitoring jobs to store snapshots in your own system.

### Who is Price Tracker API for?

Price Tracker API is for developers who want one price-search contract across several retail sites who need to feed a price intelligence service with normalized current product rows.

- **Multi-Site Price Checks.** Use `title`, `price`, `currency`, `seller`, `stock_status`, and `source_url` to support multi-site price checks.
- **Market Availability Snapshots.** Use `title`, `price`, `currency`, `seller`, `stock_status`, and `source_url` to support market availability snapshots.
- **Seller Comparison.** Use `title`, `price`, `currency`, `seller`, `stock_status`, and `source_url` to support seller comparison.
- **Catalog Validation.** Use `title`, `price`, `currency`, `seller`, `stock_status`, and `source_url` to support catalog validation.
- **Regional Offer Research.** Use `title`, `price`, `currency`, `seller`, `stock_status`, and `source_url` to support regional offer research.

It is not the right choice for checkout automation, personal account actions, guaranteed store inventory, completed-sale appraisal, or a turnkey alert dashboard. Choose it when you own the downstream comparison, storage, alerting, or analysis workflow and want a bounded collection component.

### How can I use Price Tracker API through the API or MCP?

Use Actor ID `QHfYkMSkD1L8ojBdc` or name form `truefetch/price-tracker-api` through Apify API v2, an official API client, or the hosted Apify MCP server.

#### Actor ID

```text
QHfYkMSkD1L8ojBdc
```

The stable name form is `truefetch/price-tracker-api`.

#### HTTP

```bash
curl -X POST 'https://api.apify.com/v2/acts/QHfYkMSkD1L8ojBdc/run-sync-get-dataset-items?token=$APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keyword": "gaming monitor", "country": "Germany", "max_results": 2, "platforms": ["MediaMarkt"]}'
```

#### MCP

Apify's hosted MCP server uses Streamable HTTP. Configure it with a bearer token, then ask the `call-actor` tool to run the name form and pass the same input:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=actors",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  }
}
```

Use Actor `truefetch/price-tracker-api` with this input:

```json
{
  "keyword": "gaming monitor",
  "country": "Germany",
  "max_results": 2,
  "platforms": [
    "MediaMarkt"
  ]
}
```

The [live API page](https://apify.com/truefetch/price-tracker-api/api) provides generated endpoints and SDK examples. The [official Apify MCP documentation](https://docs.apify.com/integrations/mcp) explains Streamable HTTP, OAuth, bearer-token authentication, tool selection, and how agents discover and call Actors.

### How much does Price Tracker API cost?

At the FREE tier, Price Tracker API costs **$0.00850 per stored Result row plus $0.01000 per Actor Start**, so the smallest one-row test costs **$0.01850**.

| Event | Plan tier | Unit price | Billing unit |
| --- | --- | ---: | --- |
| Actor Start | All | $0.01000 | One event per GB at run start, minimum one event |
| Result | Free | $0.00850 | Each row stored in the default Dataset |
| Result | Bronze | $0.00765 | Each row stored in the default Dataset |
| Result | Silver | $0.00680 | Each row stored in the default Dataset |
| Result | Gold | $0.00638 | Each row stored in the default Dataset |
| Result | Platinum | $0.00638 | Each row stored in the default Dataset |
| Result | Diamond | $0.00638 | Each row stored in the default Dataset |

The Result event fires once for each row stored in the default Dataset. With `max_results: 1` and one selected platform, the maximum first-test calculation is `$0.01000 + 1 × $0.00850 = $0.01850`. Empty runs still incur Actor Start but no Result row charge. Prices can change, so confirm the [live Pricing page](https://apify.com/truefetch/price-tracker-api/pricing) before a large run.

### How does Price Tracker API compare with alternatives?

Price Tracker API is best when you need repeatable product rows and API delivery without maintaining a separate collection contract for this route.

- **Manual browsing** is appropriate for a one-off purchase decision, especially when you must confirm local stock or a final checkout total. It stops scaling once you need repeated, structured rows.
- **Separate source integrations** give maximum control when your team already owns credentials, schemas, retries, and storage for every marketplace. They increase maintenance when the workflow spans more than one route.
- **The source's official site or offering** is the right place to purchase, manage an account, confirm delivery, or use first-party customer features. This Actor observes public search data and never substitutes for those actions.
- **A hosted price-history product** is better when you need an existing historical chart or managed alerts. This Actor supplies current rows that your own scheduler and database can retain over time.

Choose something else if you need guaranteed item matching, checkout execution, private account data, or a source-supported inventory commitment.

### What are the limits and troubleshooting steps?

The main limits of Price Tracker API come from live search behavior, regional catalog differences, and the meaning of a keyword result.

- **Dataset is empty →** the keyword may be too narrow, the selected country/platform pair may have no products, or the source may be unavailable. Retry the smallest profile with a broader product phrase and `max_results: 1`.
- **Fewer rows than `max_results` →** `max_results` is a ceiling, not a promise. The route stores only usable products it receives.
- **Several similar products →** marketplaces can show variants, bundles, accessories, or multiple sellers. Match on identifiers and URLs instead of title alone.
- **Price or stock differs later →** rows are observations at processing time. Recheck `product_url` and schedule a new run for a new snapshot.
- **Some fields are empty →** the 56-field schema is cross-platform; not every source publishes every identifier, seller score, return term, or warranty value.
- **Run takes longer than expected →** source response and the number of selected routes affect duration. Reduce `max_results`, select one platform, and review the run log.

For a reproducible problem, open an [Issue](https://apify.com/truefetch/price-tracker-api/issues) with the run ID, exact input, expected behavior, and one affected source URL. Do not post API tokens, account data, or private customer information.

### Frequently asked questions

Price Tracker API answers the following common implementation and buying-decision questions directly.

#### How do I track product prices across multiple websites?

Run `truefetch/price-tracker-api` with a precise `keyword`, an allowed `country`, a small positive `max_results`, and the relevant `platforms` value. Store successive Datasets in your own system if you need comparisons over time.

#### Can I use a product price monitoring api without separate retailer keys?

Yes. The Actor exposes one four-input contract and returns the same 56-field Dataset shape without requiring a separate marketplace credential from you; an Apify token is still required for authenticated API or MCP runs.

#### Is there a free product price API?

There is no permanently free promise. Apify accounts may include platform credits, but this Actor bills $0.01000 for Actor Start and $0.00850 per Result on the FREE subscription tier; check the live pricing page.

#### Can I schedule runs to monitor product prices over time?

Yes. Use Apify schedules with a bounded input, then persist each Dataset in your database or integration. The Actor returns snapshots and does not itself calculate price changes or send alerts.

#### Does `max_results` apply to the whole run?

No. It is a per-selected-platform ceiling. A multi-platform run can therefore store more than `max_results` rows, while a fixed edition with one route cannot exceed that ceiling.

#### Why are some of the 56 fields empty?

Because source cards and product pages do not expose identical attributes. Empty values distinguish unavailable source data from fabricated or guessed values.

#### Does the Actor guarantee the lowest price or local stock?

No. Search relevance, seller offers, delivery location, promotions, and inventory can change. Use the row's source link for a final purchasing or operational decision.

### Related TrueFetch Actors

These three TrueFetch Actors are the closest alternatives when your route or market focus changes.

- [Amazon Price Tracker](https://apify.com/truefetch/amazon-price-tracker) — choose it when the workflow should focus on amazon rather than this Actor's exact route.
- [eBay Price Tracker](https://apify.com/truefetch/ebay-price-tracker) — choose it when the workflow should focus on ebay rather than this Actor's exact route.
- [Walmart Price Tracker](https://apify.com/truefetch/walmart-price-tracker) — choose it when the workflow should focus on walmart rather than this Actor's exact route.

Each related Actor uses its own verified country and platform enums. Choose by the marketplace you need rather than assuming every fixed edition supports the 23-route union.

### Support

Get product guidance in the [TrueFetch community](https://t.me/TrueFetch), review the [Store page](https://apify.com/truefetch/price-tracker-api), use the [API page](https://apify.com/truefetch/price-tracker-api/api), or open an [Issue](https://apify.com/truefetch/price-tracker-api/issues) with a reproducible input and run ID.

[**Run a bounded one-result test**](https://apify.com/truefetch/price-tracker-api) · [**Open the API reference**](https://apify.com/truefetch/price-tracker-api/api)

**Last Updated:** August 10, 2026

# Actor input Schema

## `keyword` (type: `string`):

Product phrase, brand, or model to search across eligible shopping routes.

## `country` (type: `string`):

Country used to select eligible marketplace domains and retailer routes across 33 supported markets.

## `max_results` (type: `integer`):

Maximum product records returned per selected platform; enter any integer greater than zero.

## `platforms` (type: `array`):

Optional subset of 23 shopping sources; leave empty to use every source supported for the selected country.

## Actor input object example

```json
{
  "keyword": "kopfhörer",
  "country": "Germany",
  "max_results": 2,
  "platforms": [
    "OTTO"
  ]
}
```

# Actor output Schema

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

Normalized product listing records returned by this actor with source URLs.

# 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 = {
    "keyword": "kopfhörer",
    "country": "Germany",
    "max_results": 2,
    "platforms": [
        "OTTO"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/price-tracker-api").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 = {
    "keyword": "kopfhörer",
    "country": "Germany",
    "max_results": 2,
    "platforms": ["OTTO"],
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/price-tracker-api").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 '{
  "keyword": "kopfhörer",
  "country": "Germany",
  "max_results": 2,
  "platforms": [
    "OTTO"
  ]
}' |
apify call truefetch/price-tracker-api --silent --output-dataset

```

## MCP server setup

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

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/QHfYkMSkD1L8ojBdc/builds/z825sRVplYbrBpOrH/openapi.json