# Price Monitoring API - Competitor Offers, Price Recommendations (`nabeelbaghoor/price-monitoring-dynamic-pricing-api`) Actor

Export ecommerce price monitoring data: competitor offers per product and shop with price, shipping, rank and stock, dynamic pricing recommendations with old and new price and position, product catalogue, recommendation history and monitoring status. Bring your own key.

- **URL**: https://apify.com/nabeelbaghoor/price-monitoring-dynamic-pricing-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** E-commerce, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 pricing record returneds

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/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 Monitoring API - Competitor Offers, Price Recommendations

Export your price monitoring account's data as a clean dataset: every competitor offer per product and shop, every dynamic pricing recommendation, and the catalogue behind them, ready for a spreadsheet, a BI tool or a repricing script.

### What it collects

- **Competitor offers**: the newest offer per product on each monitored domain, with shop or seller name, unit price, delivery costs, total price, rank by total and unit price, stock, delivery time, offer URL and when it was retrieved.
- **Price recommendations**: the newest recommended price per product in a time range, with your current price, the percentage change, your market position before and after, the price boundaries in force and the pricing strategy branch that decided it.
- **Price recommendation history**: every recommendation calculated for chosen products over any date range.
- **Products**: the contract's catalogue with GTIN, your own product ID, reference price and minimum and maximum price boundaries, optionally filtered to a list of your product IDs.
- **Monitoring status**: when each product was last monitored on each domain and the outcome, such as ProductFound or ProductNotAvailable.
- **Monitored domains**: every shop and marketplace the platform can monitor, across 50+ countries, with its offer sources.

### Input

| Field | What it does |
| --- | --- |
| What to read | One mode per run. Defaults to the domain list, which needs only credentials. |
| Contract ID | The contract to read. Required by every mode except the domain list. |
| Start date, End date, Lookback hours | Time range for offers, recommendations and history. Blank means the last 48 hours. |
| Product IDs | Internal product IDs for recommendation history and monitoring status. |
| Customer product IDs | Your own IDs, to restrict the products mode to them. |
| Only these domains | Keep offers from these domains only, for example amazon.de. |
| Skip ignored offers, Only in-stock offers | Offer filters on the API's own ignored and availability flags. |
| Only price changes | Keep recommendations whose price differs from your current price. |
| Include product tags | Return the tags imported with each product. |
| Maximum results | A row cap for the whole run. |
| API username, API password | Your own credentials, stored as secrets. |

### FAQ

#### What is a price monitoring API used for?

Pricing teams at online retailers and brands use a price monitoring API to pull competitor prices and repricing suggestions out of their pricing platform and into their own systems. Typical jobs are a nightly export of competitor offers into a data warehouse, a daily list of price recommendations that changed the price to feed a shop's repricer, a price index against Amazon, bol.com or other marketplaces, and a check of which products failed to be monitored so they can be fixed.

#### What data does one competitor offer row contain?

The product ID, your customer product ID, GTIN and name, the domain the offer was found on, the shop or marketplace seller name, unit price, delivery costs, total price, currency, the offer's position by total price and by unit price, availability, minimum and maximum delivery time in hours, whether the platform ignores the offer, the offer URL, and when it was retrieved and stored. Your own reference price sits alongside it for comparison.

#### How are dynamic pricing recommendations explained?

Each price recommendation row gives the recommended price and delivery costs, your current cheapest price and its delivery costs, the relative price change in percent, your market position now and the projected position at the new price (1 is cheapest), the minimum and maximum price boundaries at calculation time, the relevant domain, and the name and node of the strategy branch that set the price.

#### Which modes need a contract ID and which need product IDs?

Only the domain list needs neither. Competitor offers, price recommendations and products need the contract ID alone. Price recommendation history and monitoring status also need product IDs, which are the productId column of a products or offers run.

#### How long a time range can I read?

Offers and price recommendations take the range you give and return the newest record per product inside it. Recommendation history is limited by the API to 48 hours per call, so this actor walks a longer range in 48 hour windows for you.

#### Can this actor change anything in my pricing account?

No. Every route it calls is a read. The API also documents routes that upload or delete products, offers and orders, change contract settings, callbacks and plugin registrations, and create companies and contracts. None of them is wired. The product query is sent as a POST because the API documents it that way, but it only carries the page and the IDs to look up.

#### Do I need an API key?

Yes. This actor is bring-your-own-key and never ships credentials of its own. The API uses HTTP Basic authentication with your account's API username and password; enter both, paste username:password in the password field, or set the DATA\_API\_USERNAME and DATA\_API\_KEY environment secrets. A JWT bearer token pasted into the password field also works. Missing credentials end the run cleanly before any request, and refused credentials end it cleanly with the API's answer.

#### Does the output contain personal data?

No account or user data is read. Rows carry products, prices, shops and marketplace seller names as the monitored domains list them. The credentials never appear in a row or in the log.

#### What does it cost?

Pay per result. A pricing record, meaning one competitor offer, one price recommendation or one catalogue product, is one charge. Domain rows and monitoring status rows are priced lower as small reference rows. A product ID that returns nothing becomes a row marked found false and is never charged.

### Example output

```json
{
  "mode": "priceRecommendations",
  "contractId": "qbcxvb",
  "found": true,
  "retrievedAt": "2026-09-26T08:00:00.000Z",
  "recordType": "priceRecommendation",
  "productId": "PROD-001",
  "customerProductId": "CUST-PROD-001",
  "gtin": "1234567890123",
  "price": 27.99,
  "deliveryCosts": 4.99,
  "currency": "EUR",
  "oldPrice": 29.99,
  "oldDeliveryCosts": 4.99,
  "relativePriceChangePercentage": 6.67,
  "oldPosition": 5,
  "newPosition": 3,
  "minPriceBoundary": 20,
  "maxPriceBoundary": 50,
  "relevantDomain": "amazon.de",
  "strategyBranchName": "CompetitorPricing",
  "strategyLeafNodeId": 123,
  "timestamp": "2024-01-15T14:30:00Z",
  "tags": null,
  "originalTags": null,
  "note": null
}
```

### Keyword map

price monitoring API, competitor price monitoring, dynamic pricing API, repricing API, price recommendation API, ecommerce price tracking, competitor offers export, marketplace price monitoring, Amazon price monitoring, price intelligence data, pricing strategy export, price index, retail pricing software API, price optimization data, product price history, GTIN price comparison.

# Actor input Schema

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

One mode per run. The domain list needs nothing but credentials, so it is the default. Every other mode reads one contract of your account and needs its contract ID.

## `contractId` (type: `string`):

The contract to read, as shown in your account, for example qbcxvb. Required by every mode except the domain list.

## `startDate` (type: `string`):

Start of the time range for offers, price recommendations and recommendation history. An ISO 8601 date such as 2026-09-01 (read as midnight UTC) or a UTC date and time such as 2026-09-01T06:00:00Z. Left blank, the range is the last lookback hours.

## `endDate` (type: `string`):

End of the time range, in the same format. Left blank, it is now, or the start date plus the lookback hours.

## `lookbackHours` (type: `integer`):

How far back to read when no start date is given. 48 hours is the provider's own default for offers. Recommendation history longer than 48 hours is read in 48 hour windows, the longest range that route accepts.

## `productIds` (type: `array`):

Internal product IDs, one per line, for recommendation history and monitoring status. These are the productId column of a products or offers run. Monitoring status takes numeric IDs only.

## `customerProductIds` (type: `array`):

Your own product IDs, one per line, to restrict the products mode to them. Left empty, the whole catalogue is read. A customer product ID the contract does not hold becomes an uncharged row saying so.

## `domains` (type: `array`):

Keep only competitor offers found on these domains, one per line, written as the domain list shows them, for example amazon.de. Left empty, offers from every monitored domain are kept.

## `excludeIgnored` (type: `boolean`):

Leave out competitor offers that the platform's own filters have marked as ignored.

## `onlyAvailable` (type: `boolean`):

Keep only competitor offers explicitly reported as available. Offers without availability information are left out when this is on.

## `onlyPriceChanges` (type: `boolean`):

For price recommendations and history, keep only recommendations whose price differs from your current price.

## `includeTags` (type: `boolean`):

Ask the API to return the tags imported with each product, such as category or brand, for offers, price recommendations and products.

## `maxResults` (type: `integer`):

Stop after this many rows. One product can have dozens of competitor offers, so this is what bounds an offers run on a large catalogue.

## `requestsPerMinute` (type: `integer`):

Pacing ceiling for calls to the API.

## `username` (type: `string`):

The API username of your own account, sent with HTTP Basic authentication. This actor is bring-your-own-key and never ships credentials of its own. Leave blank to use the DATA\_API\_USERNAME environment secret.

## `apiKey` (type: `string`):

The API password of your own account. You can also paste username:password here and leave the username blank, or paste a JWT bearer token. Leave blank to use the DATA\_API\_KEY environment secret.

## `baseUrl` (type: `string`):

Override the host the actor calls. Only useful for testing against a different environment.

## Actor input object example

```json
{
  "mode": "domains",
  "lookbackHours": 48,
  "excludeIgnored": false,
  "onlyAvailable": false,
  "onlyPriceChanges": false,
  "includeTags": false,
  "maxResults": 1000,
  "requestsPerMinute": 60
}
```

# Actor output Schema

## `records` (type: `string`):

One row per offer, recommendation, product, status or domain.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/price-monitoring-dynamic-pricing-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/price-monitoring-dynamic-pricing-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 '{}' |
apify call nabeelbaghoor/price-monitoring-dynamic-pricing-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nabeelbaghoor/price-monitoring-dynamic-pricing-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/etMAcjad6qHHItpth/builds/tfky2PbFftn9FNdS4/openapi.json