# Shopify Markets Price Checker (`kamnev.apps/shopify-markets-feed-auditor`) Actor

Compare expected prices with exact-variant, country-verified Shopify API evidence. $0.01 per verified comparison; unverified $0 Actor fee. Max 20 checks/$0.20 Actor fees per run. API only; pages and Merchant Center unchecked. Apify terms apply separately.

- **URL**: https://apify.com/kamnev.apps/shopify-markets-feed-auditor.md
- **Developed by:** [KamnevApps](https://apify.com/kamnev.apps) (community)
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 verified api checks

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

## Shopify Markets Price Checker

Compare supplied expected prices with a Shopify Storefront API observation for the **same variant and a verified country context**. Export the evidence and recheck the same rows after a change.

**Bounded API checks on Apify.** Verified comparisons use the Actor event pricing below. Unverified rows have no Actor event fee; platform and account terms apply separately.

This is an API price check. It does **not** inspect the landing page, initial HTML, JSON-LD, Googlebot, checkout or private Merchant Center data. An API match is not a Merchant Center clearance. A difference is something to investigate, not proof of a store error.

[Read the free saved example](https://api.apify.com/v2/key-value-stores/Di4fqSb1W3OpmYkJN/records/REPORT.html) · [See the pilot and scope](https://kamnevapps.com/shopify-markets-feed-auditor/)

The saved example needs no sign-in and starts no Actor run. Its expected prices were entered manually; no customer feed was supplied. The example stores are not customers or partners, and the observations establish no merchant fault.

### Three jobs

1. **Check the country before the price.** Both the API localization country and response context must match the requested country. The exact variant must be present. A silent fallback is unverified, even if the price looks plausible.
2. **Compare a supplied feed row with dated evidence.** Expected and observed price/currency stay side by side with the source URL, response hash and a compact evidence snippet. No exchange-rate guess or rounding tolerance.
3. **Recheck a small agency batch.** Supply the earlier report to see new differences, lost verification or a resolution in the API. Changing expected prices starts another comparison scope. The landing page and Merchant Center remain unchecked.

These functions are not claimed as unique. Existing feed auditors and native Merchant Center diagnostics may already cover a client's task. This pilot is useful only if verified country/variant evidence answers an outstanding question.

### Price per verified API comparison

The Actor charges **$0.01 per verified exact-variant and country API comparison**. Both the localization country and returned response context must match the target country. Verified API matches, price differences and currency differences count as comparisons.

- **Unverified / unknown row: $0 Actor event fee.** A missing variant, blocked source or inconclusive country context is not a verified comparison.
- **Maximum $0.20 in Actor event fees per run:** at most 20 checks, 10 distinct variants and 2 countries.
- **Fresh rechecks charge again** for their verified comparisons, including unchanged results. Supplying an earlier report does not make a fresh observation free.

The cap covers this Actor's event fees. An Apify account is required; account, payment and [platform terms](https://docs.apify.com/legal/general-terms-and-conditions) apply separately. Review the displayed price and spending limit before starting a paid run.

### Who it is for

An agency or store team with a specific multi-market price question, an export it is entitled to share, and permission to check the store. Start with affected variants rather than the whole catalog. Do not include customer/order data, private authentication links, credentials or personal data.

The pilot accepts at most **20 variant-country rows, 10 distinct variants and 2 countries**. Source lookup checks the first 100 variants returned for a product; an absent target variant stays unverified. Access restrictions, unsupported currencies, missing context or API limitations can leave rows unverified. No proxy rotation, login or restriction bypass is used.

### JSON input

In Apify's Input tab, use the JSON editor to supply `rows`, or paste CSV into `csvText`. Choose one format. Starting a run requests fresh API observations under the pricing above.

The default input checks one unaffiliated public-store variant with a manually entered expected price; starting it can incur $0.01 in Actor event fees. Remove the example JSON rows before using CSV.

This input reproduces the scope of the free example with **manually entered expectations**. Prices and country verification may differ on a fresh run. Replace these rows with product URLs and expected prices you are authorized to check:

```json
{
  "pilotId": "public-source-example",
  "rows": [
    {
      "rowId": "colourpop-us",
      "url": "https://colourpop.com/products/colour-me-merry-advent-calendar-2026?variant=42754994372690",
      "country": "US",
      "expectedPrice": "99.00",
      "expectedCurrency": "USD"
    },
    {
      "rowId": "colourpop-fr",
      "url": "https://colourpop.com/products/colour-me-merry-advent-calendar-2026?variant=42754994372690",
      "country": "FR",
      "expectedPrice": "91.95",
      "expectedCurrency": "EUR"
    },
    {
      "rowId": "allbirds-fr",
      "url": "https://www.allbirds.com/products/womens-allbirds-flip-flop-dusty-pink?variant=42146889039952",
      "country": "FR",
      "expectedPrice": "50.00",
      "expectedCurrency": "USD"
    }
  ]
}
```

Supply the exact numeric variant ID in the URL or a `variantId` field; conflicting IDs fail before any source call. The row's `country` is the target. Country or currency hints in the URL must agree with the row, and neither proves which country the API actually returned.

### CSV input

Supply `csvText` **instead of** `rows`:

```json
{
  "pilotId": "colourpop-fr-example",
  "csvText": "rowId,url,country,expectedPrice,expectedCurrency\ncolourpop-fr,https://colourpop.com/products/colour-me-merry-advent-calendar-2026?variant=42754994372690,FR,91.95,EUR"
}
```

This bounded pilot accepts pasted UTF-8 CSV or JSON, not a remote feed download. It does not fetch arbitrary feed URLs or connect to a Google account. Currency support is deliberately limited and validated before the run; unsupported formats fail with a clear error.

### Local use

Node.js 22 or later:

```sh
npm ci
npm run verify
npm run local -- input.json --output storage/first-check
npm run local -- input.json --baseline storage/first-check/PRICE-PROOF.json --output storage/recheck
```

Output directories must be empty so earlier evidence is preserved. Local commands make bounded read-only HTTPS source requests. Actor event billing applies to native Apify runs, not these local commands.

On Apify, supply the earlier `PRICE-PROOF.json` as `previousReport` for a recheck. It is a user-supplied baseline, not independently authenticated history.

Keep the same exact variants, countries and expected prices to compare observations. `pilotId` is a report label, not a billing or deduplication key. There is no `requestId` input; starting another run collects a fresh observation.

### Outputs and interpretation

| Output | Contents |
| --- | --- |
| `REPORT.html` | Readable register, filters, evidence, CSV/JSON downloads; no external assets or tracking |
| `PRICE-PROOF.csv` | Flat agency/spreadsheet handoff; formula-like cells neutralized |
| `PRICE-PROOF.json` | Full observations and a reusable baseline |
| `REPORT.md` | Plain-text summary and scope |
| `BILLING-RECEIPT.json` | Final Actor event fee outcome for an Apify run; check the native run ledger if reconciliation is required |
| Dataset | One summary row per requested check |

The evidence report is saved before any charge attempt, so its billing status can remain `pending`. Use the separate receipt for the final outcome. An uncertain charge is not retried automatically; inspect the native run ledger before starting another paid run.

| Result | Meaning |
| --- | --- |
| `api_match` | Supplied and observed API price/currency agree, with the exact variant and country context verified. Page unchecked |
| `price_difference` | Same verified country/variant and currency, different numeric price. Check expected price and tax basis |
| `currency_difference` | Verified country/variant, but observed currency differs. No FX conversion performed |
| `unverified` | Required evidence is missing, blocked, unsupported or inconclusive. No pass or price-error claim |

`resolved_in_api` means only the earlier API difference cleared with unchanged expected inputs. It does not prove that Google accepted the item or that the visible page was fixed.

### Private input and source access

Only the product handle, variant identity and requested country are used for the public read-only API observation. No Admin API or Merchant Center credentials are requested. Public DNS, HTTPS, robots policy, response sizes, request counts and total request time are bounded. Redirects and nonpublic destinations are refused. Robots permission alone is not a commercial data license or proof of complete store coverage.

The `rows`, `csvText` and `previousReport` input fields are secret in the Apify schema: the platform encrypts them before saving INPUT, and the SDK decrypts them at runtime. The Actor requires `RESTRICTED` report storage and dataset access before reading input or calling a source. Verify the deployed schema and storage configuration before sharing client data; local input files remain your responsibility. Do not put private data in the report label. Download and share private reports only with the people who should receive them.

Independent tool by KamnevApps. Not affiliated with Shopify or Google. No stock, tax advice, checkout total, Googlebot reproduction, guaranteed savings or Merchant Center approval claims.

# Actor input Schema

## `pilotId` (type: `string`):

Short report label, not a billing or deduplication key. Do not include customer personal data.

## `rows` (type: `array`):

Each row: rowId, url (HTTPS Shopify product URL with ?variant=ID), country (ISO country code), expectedPrice (decimal string), expectedCurrency (ISO currency). Maximum 20 rows, 10 exact variants and 2 countries. Supply rows OR CSV, not both. This field is encrypted in stored INPUT. The public example has a manually entered expectation; replace it with your rows.

## `csvText` (type: `string`):

Headers: rowId,url,country,expectedPrice,expectedCurrency. Supply rows OR CSV. UTF-8 CSV text, not a remote feed URL. Maximum 20 rows, 10 variants and 2 countries. This field is encrypted in stored INPUT. Remove the example JSON rows value before using CSV.

## `previousReport` (type: `object`):

Paste an earlier PRICE-PROOF.json. Keep variants, countries and expected prices unchanged. This is a user-supplied baseline, not independently authenticated history. A fresh recheck charges again for verified comparisons. This field is encrypted in stored INPUT.

## Actor input object example

```json
{
  "pilotId": "public-source-example",
  "rows": [
    {
      "rowId": "public-example-colourpop-us",
      "url": "https://colourpop.com/products/colour-me-merry-advent-calendar-2026?variant=42754994372690",
      "country": "US",
      "expectedPrice": "99.00",
      "expectedCurrency": "USD"
    }
  ]
}
```

# Actor output Schema

## `report` (type: `string`):

No description

## `csv` (type: `string`):

No description

## `evidence` (type: `string`):

No description

## `billingReceipt` (type: `string`):

No description

## `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 = {
    "pilotId": "public-source-example",
    "rows": [
        {
            "rowId": "public-example-colourpop-us",
            "url": "https://colourpop.com/products/colour-me-merry-advent-calendar-2026?variant=42754994372690",
            "country": "US",
            "expectedPrice": "99.00",
            "expectedCurrency": "USD"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kamnev.apps/shopify-markets-feed-auditor").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 = {
    "pilotId": "public-source-example",
    "rows": [{
            "rowId": "public-example-colourpop-us",
            "url": "https://colourpop.com/products/colour-me-merry-advent-calendar-2026?variant=42754994372690",
            "country": "US",
            "expectedPrice": "99.00",
            "expectedCurrency": "USD",
        }],
}

# Run the Actor and wait for it to finish
run = client.actor("kamnev.apps/shopify-markets-feed-auditor").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 '{
  "pilotId": "public-source-example",
  "rows": [
    {
      "rowId": "public-example-colourpop-us",
      "url": "https://colourpop.com/products/colour-me-merry-advent-calendar-2026?variant=42754994372690",
      "country": "US",
      "expectedPrice": "99.00",
      "expectedCurrency": "USD"
    }
  ]
}' |
apify call kamnev.apps/shopify-markets-feed-auditor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kamnev.apps/shopify-markets-feed-auditor"
        }
    }
}
```

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/wH2ucSGVrZhNqWXQ8/builds/u0tfkcI8btZCUJnwU/openapi.json