# Instacart Storefront Price Scraper (`crawlerbros/instacart-storefront-price-scraper`) Actor

Scrape real-time grocery prices from Instacart storefronts. Search products by keyword, look up items by ID, or pull a retailer's store overview - no login, no API key.

- **URL**: https://apify.com/crawlerbros/instacart-storefront-price-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Instacart Storefront Price Scraper

Scrape **real-time grocery prices from Instacart storefronts** — Costco, Safeway, Publix, Kroger, Walgreens, ALDI, Wegmans, and 20+ other Instacart-partnered retailers. Search any storefront by keyword, browse a department/aisle, look up specific products by item ID, or pull a retailer's store overview with trending items. No login, no API key, no cookies required.

### What this actor does

- **Five modes:** `search` (keyword → priced results), `browseAisle` (department/category browse), `listAisles` (discover a retailer's department/aisle taxonomy), `productDetail` (lookup by item ID), `storeOverview` (retailer info + trending items)
- **30 retailers** available via dropdown, plus a free-text override for any other Instacart-partnered retailer
- **Real prices** — current price, price-per-unit, pack/unit size, regular (pre-discount) price, discount %, and sort by price (low-to-high / high-to-low)
- **Deals & ratings** — surfaces sale badges/promo labels and public star ratings/review counts wherever Instacart shows them
- **Filters:** min/max price, brand name, in-stock only, on-sale only, min rating
- **Empty fields are omitted** from every record

### Output per product

- `itemId` — full Instacart item ID (e.g. `items_74-17444603`), reusable in `productDetail` mode
- `productId`, `legacyId` — Instacart's internal product identifiers
- `name`, `brandName`, `size`, `category`
- `priceString` (e.g. `$17.40`), `price` (numeric, e.g. `17.4`)
- `pricePerUnitString` (e.g. `$0.09/oz`), `pricingUnitString` (e.g. `3 x 64 oz`)
- `regularPriceString` / `regularPrice` — pre-discount price when the item is on sale (e.g. `$19.67`)
- `discountPercentString` (e.g. `30%`), `promoLabel` (e.g. `$6 off; limit 5`), `onSale` (boolean)
- `rating` (0–5) and `reviewCount` — when Instacart publicly shows a star rating for the item
- `imageUrl` — product photo
- `available`, `stockLevel`
- `dietaryAttributes[]` — e.g. `organic`, `lactose_free`, `gluten_free`
- `tags[]` — e.g. `storeBrand`
- `aisleSlug` — the aisle/collection slug the item was found in (mode=browseAisle only)
- `retailerSlug`, `retailerName`
- `productUrl` / `sourceUrl`
- `recordType: "product"`, `scrapedAt`

### Output per retailer (mode = `storeOverview`)

- `retailerId`, `retailerSlug`, `retailerName`, `retailerType`
- `categories[]` — e.g. `grocery`, `club`, `wholesale`
- `sourceUrl`
- `recordType: "retailer"`, `scrapedAt`

### Output per aisle/department (mode = `listAisles`)

- `aisleId`, `aisleName`, `aisleSlug` — pass `aisleSlug` into `mode=browseAisle` to fetch its products
- `collectionType` — e.g. `department`, `retailer_collection_v2`, `dynamic`
- `parentAisleId` / `parentAisleName` — present for sub-aisles nested under a department
- `childAisleCount` — number of sub-aisles under a top-level department
- `retailerSlug`, `retailerName`
- `sourceUrl`
- `recordType: "aisle"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `browseAisle` / `listAisles` / `productDetail` / `storeOverview` |
| `retailerSlug` | string | `costco` | Retailer to scrape (dropdown of 30 popular retailers) |
| `customRetailerSlug` | string | – | Any Instacart retailer slug not in the dropdown; overrides `retailerSlug` |
| `searchQuery` | string | `milk` | Keyword to search (mode=search) |
| `orderBy` | string | `bestMatch` | `bestMatch` / `priceAsc` / `priceDesc` (mode=search, browseAisle) |
| `aisleSlug` | string | `9797-crackers` | Department/aisle (collection) slug to browse (mode=browseAisle); discover slugs via `mode=listAisles` |
| `itemIds` | array | – | Full item IDs to look up (mode=productDetail) |
| `minPrice` | int | – | Drop items priced below this (USD) |
| `maxPrice` | int | – | Drop items priced above this (USD) |
| `brandContains` | string | – | Keep only items whose brand contains this text |
| `inStockOnly` | boolean | `false` | Drop out-of-stock items |
| `onSaleOnly` | boolean | `false` | Keep only items currently discounted from their regular price |
| `minRating` | number | – | Drop items with an average rating below this (0–5); items without a public rating are kept |
| `maxItems` | int | `20` | Hard cap on emitted records (1–200) |
| `proxyConfiguration` | object | Apify proxy (auto) | Optional; enable if you see repeated 429/403s |

#### Example: search a retailer by keyword

```json
{
  "mode": "search",
  "retailerSlug": "costco",
  "searchQuery": "organic eggs",
  "orderBy": "priceAsc",
  "maxItems": 30
}
````

#### Example: filter by price and brand

```json
{
  "mode": "search",
  "retailerSlug": "safeway",
  "searchQuery": "paper towels",
  "minPrice": 5,
  "maxPrice": 25,
  "brandContains": "bounty",
  "inStockOnly": true
}
```

#### Example: look up specific products by ID

```json
{
  "mode": "productDetail",
  "retailerSlug": "costco",
  "itemIds": ["items_74-17444603", "items_74-19871524"]
}
```

#### Example: store overview for a retailer not in the dropdown

```json
{
  "mode": "storeOverview",
  "retailerSlug": "costco",
  "customRetailerSlug": "sprouts-farmers-market"
}
```

#### Example: discover a retailer's departments/aisles

```json
{
  "mode": "listAisles",
  "retailerSlug": "costco",
  "maxItems": 200
}
```

#### Example: browse a department/aisle for on-sale items

```json
{
  "mode": "browseAisle",
  "retailerSlug": "costco",
  "aisleSlug": "dynamic_collection-sales",
  "onSaleOnly": true,
  "orderBy": "priceAsc",
  "maxItems": 50
}
```

#### Example: highly-rated products in a specific aisle

```json
{
  "mode": "browseAisle",
  "retailerSlug": "safeway",
  "aisleSlug": "produce",
  "minRating": 4.5,
  "maxItems": 30
}
```

### Use cases

- **Price monitoring** — track grocery price changes across retailers over time
- **Market research** — compare pricing and product assortment between chains
- **Deal-hunting tools** — feed a price-comparison app or browser extension with `onSaleOnly` results
- **Retail analytics** — monitor stock availability and pricing trends by department/aisle
- **Coupon / cashback apps** — identify current prices and discount % to calculate savings
- **Category audits** — use `listAisles` + `browseAisle` to pull a full department's catalog

### FAQ

**Is this affiliated with Instacart?**
No — this is an independent, third-party actor that reads Instacart's public storefront pages. It is not affiliated with, endorsed by, or supported by Instacart.

**Do I need an Instacart account or login?**
No. All data comes from Instacart's public, unauthenticated storefront pages, the same pages any visitor sees when browsing without signing in.

**Why do prices show a specific location's pricing?**
Instacart prices are location-based. Without a saved delivery address, the actor uses Instacart's default guest location (typically the San Francisco Bay Area). Prices may differ from your local store.

**Why doesn't a retailer I searched for show up in results?**
Only retailers that partner with Instacart are available. Use `customRetailerSlug` with the retailer's exact Instacart storefront slug (found in the URL `instacart.com/store/<slug>/storefront`) if it's not in the dropdown.

**How many results does `search` mode return?**
Instacart's search returns a curated set of best-match results (similar to what a shopper sees on the first search screen) rather than a deep paginated list — typically 10–30 relevant items per query, capped by `maxItems`.

**How fresh is the pricing data?**
Prices are fetched live at run time directly from Instacart's storefront.

**What does `productId` vs `legacyId` mean?**
Both are Instacart's own internal identifiers for the same product; some downstream Instacart surfaces reference one or the other, so both are included for convenience.

**Why do some `productDetail` lookups return an item without price fields?**
Instacart resolves each guest session to a default region/store. If an `itemId` was originally captured from a `search`/`storeOverview` run in a different region than the current run resolves to, Instacart may return the item's catalog details without live pricing for that ID. For guaranteed pricing, use `itemIds` captured from a `search` or `storeOverview` result in the same run, or re-run `search`/`storeOverview` first to get current-session item IDs.

**Why does `productUrl` return a 403 with a bare `curl` (no headers)?**
Instacart blocks requests with no User-Agent header at all. Any normal HTTP client (browsers, `requests`, `curl -A "Mozilla/5.0 ..."`) works fine — this is standard bot-mitigation, not a broken link.

**How do I find a valid `aisleSlug` for `browseAisle`?**
Run `mode=listAisles` first for your chosen retailer — it returns every department and sub-aisle slug Instacart exposes for that storefront (they differ per retailer). You can also copy a slug directly from a collection page URL: `instacart.com/store/<retailer>/collections/<slug>`.

**Do `rating` and `reviewCount` appear on every product?**
No — Instacart only shows a public star rating for products that have received enough reviews. When it's not shown on the storefront, the actor omits the field rather than guessing a value.

**What counts as "on sale" (`onSale` / `onSaleOnly`)?**
An item is marked `onSale: true` when Instacart's storefront shows a crossed-out regular price (`regularPriceString`) alongside the current price. Retailer-wide deals can be browsed directly via `mode=browseAisle` with `aisleSlug: "dynamic_collection-sales"`.

**Are there aisles/collections this actor can't browse?**
`browseAisle` covers every department and sub-aisle slug returned by `mode=listAisles` for a given retailer. Deeper, personalized, or login-gated collections (e.g. order history-based recommendations) aren't included since they require an authenticated account.

# Actor input Schema

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

What to fetch.

## `retailerSlug` (type: `string`):

Which Instacart-partnered retailer's storefront to scrape. Pick from the list, or use "Custom retailer slug" below to supply any Instacart retailer slug not in this list.

## `customRetailerSlug` (type: `string`):

Any Instacart retailer slug, e.g. `whole-foods-market` or `sprouts-farmers-market`. Find a retailer's slug in its Instacart storefront URL: instacart.com/store/<slug>/storefront. Leave empty to use the Retailer dropdown instead.

## `searchQuery` (type: `string`):

Keyword to search for within the selected retailer's storefront, e.g. `milk`, `organic eggs`, `paper towels`. Results are filtered so every returned item's name/brand/category contains each significant word of your query (generic words like "organic" are ignored for this check). Note: this is a substring check, not full product understanding, so on rare occasions an item that happens to contain all your query words in an unrelated context (e.g. a "milk chocolate"-flavored candy matching a search for "almond milk") can still slip through.

## `orderBy` (type: `string`):

How to order results.

## `aisleSlug` (type: `string`):

Which department/aisle (a.k.a. "collection") to browse within the selected retailer, e.g. `9797-crackers`, `produce`, or `dynamic_collection-sales` (retailer-wide deals). Run `mode=listAisles` first to get the exact slugs available for your chosen Retailer, or copy one from an Instacart collection URL: instacart.com/store/<retailer>/collections/<slug>.

## `itemIds` (type: `array`):

Full Instacart item IDs to look up, e.g. `items_74-17444603` (copy from a `search`, `browseAisle`, or `storeOverview` result's `itemId` field). Must all belong to the same Retailer selected above.

## `minPrice` (type: `integer`):

Drop items priced below this amount (whole dollars).

## `maxPrice` (type: `integer`):

Drop items priced above this amount (whole dollars).

## `brandContains` (type: `string`):

Keep only items whose brand name contains this text (case-insensitive).

## `inStockOnly` (type: `boolean`):

Drop items that are marked out of stock.

## `onSaleOnly` (type: `boolean`):

Keep only items currently discounted from their regular price (has a `regularPrice` higher than `price`).

## `minRating` (type: `number`):

Drop items with an average customer rating below this (out of 5). Items without a public rating are kept (unknown, not zero).

## `maxItems` (type: `integer`):

Hard cap on emitted records.

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

Optional. Instacart's storefront does not require a proxy in most regions; enable the free Apify datacenter proxy if you see repeated 429/403 responses.

## Actor input object example

```json
{
  "mode": "search",
  "retailerSlug": "costco",
  "searchQuery": "milk",
  "orderBy": "bestMatch",
  "aisleSlug": "9797-crackers",
  "itemIds": [
    "items_74-17444603"
  ],
  "inStockOnly": false,
  "onSaleOnly": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing all scraped Instacart products / store records.

# 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 = {
    "mode": "search",
    "retailerSlug": "costco",
    "searchQuery": "milk",
    "orderBy": "bestMatch",
    "aisleSlug": "9797-crackers",
    "itemIds": [
        "items_74-17444603"
    ],
    "inStockOnly": false,
    "onSaleOnly": false,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/instacart-storefront-price-scraper").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 = {
    "mode": "search",
    "retailerSlug": "costco",
    "searchQuery": "milk",
    "orderBy": "bestMatch",
    "aisleSlug": "9797-crackers",
    "itemIds": ["items_74-17444603"],
    "inStockOnly": False,
    "onSaleOnly": False,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/instacart-storefront-price-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "retailerSlug": "costco",
  "searchQuery": "milk",
  "orderBy": "bestMatch",
  "aisleSlug": "9797-crackers",
  "itemIds": [
    "items_74-17444603"
  ],
  "inStockOnly": false,
  "onSaleOnly": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/instacart-storefront-price-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/instacart-storefront-price-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instacart Storefront Price Scraper",
        "description": "Scrape real-time grocery prices from Instacart storefronts. Search products by keyword, look up items by ID, or pull a retailer's store overview - no login, no API key.",
        "version": "1.0",
        "x-build-id": "9F4nFWg9vwz3ANmaD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~instacart-storefront-price-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-instacart-storefront-price-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~instacart-storefront-price-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-instacart-storefront-price-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~instacart-storefront-price-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-instacart-storefront-price-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode",
                    "retailerSlug"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "browseAisle",
                            "listAisles",
                            "productDetail",
                            "storeOverview"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "retailerSlug": {
                        "title": "Retailer",
                        "enum": [
                            "costco",
                            "safeway",
                            "publix",
                            "cvs",
                            "walgreens",
                            "aldi",
                            "wegmans",
                            "kroger",
                            "meijer",
                            "food-lion",
                            "giant-eagle",
                            "vons",
                            "randalls",
                            "king-soopers",
                            "fred-meyer",
                            "ralphs",
                            "hy-vee",
                            "shoprite",
                            "winn-dixie",
                            "sams-club",
                            "gristedes",
                            "jewel-osco",
                            "acme-markets",
                            "pavilions",
                            "tom-thumb",
                            "smart-final",
                            "bevmo",
                            "cub",
                            "petco",
                            "staples"
                        ],
                        "type": "string",
                        "description": "Which Instacart-partnered retailer's storefront to scrape. Pick from the list, or use \"Custom retailer slug\" below to supply any Instacart retailer slug not in this list.",
                        "default": "costco"
                    },
                    "customRetailerSlug": {
                        "title": "Custom retailer slug (overrides Retailer above)",
                        "type": "string",
                        "description": "Any Instacart retailer slug, e.g. `whole-foods-market` or `sprouts-farmers-market`. Find a retailer's slug in its Instacart storefront URL: instacart.com/store/<slug>/storefront. Leave empty to use the Retailer dropdown instead."
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Keyword to search for within the selected retailer's storefront, e.g. `milk`, `organic eggs`, `paper towels`. Results are filtered so every returned item's name/brand/category contains each significant word of your query (generic words like \"organic\" are ignored for this check). Note: this is a substring check, not full product understanding, so on rare occasions an item that happens to contain all your query words in an unrelated context (e.g. a \"milk chocolate\"-flavored candy matching a search for \"almond milk\") can still slip through.",
                        "default": "milk"
                    },
                    "orderBy": {
                        "title": "Sort order (mode=search, browseAisle)",
                        "enum": [
                            "bestMatch",
                            "priceAsc",
                            "priceDesc"
                        ],
                        "type": "string",
                        "description": "How to order results.",
                        "default": "bestMatch"
                    },
                    "aisleSlug": {
                        "title": "Aisle / department slug (mode=browseAisle)",
                        "type": "string",
                        "description": "Which department/aisle (a.k.a. \"collection\") to browse within the selected retailer, e.g. `9797-crackers`, `produce`, or `dynamic_collection-sales` (retailer-wide deals). Run `mode=listAisles` first to get the exact slugs available for your chosen Retailer, or copy one from an Instacart collection URL: instacart.com/store/<retailer>/collections/<slug>."
                    },
                    "itemIds": {
                        "title": "Item IDs (mode=productDetail)",
                        "type": "array",
                        "description": "Full Instacart item IDs to look up, e.g. `items_74-17444603` (copy from a `search`, `browseAisle`, or `storeOverview` result's `itemId` field). Must all belong to the same Retailer selected above.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "minPrice": {
                        "title": "Min price (USD)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Drop items priced below this amount (whole dollars)."
                    },
                    "maxPrice": {
                        "title": "Max price (USD)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Drop items priced above this amount (whole dollars)."
                    },
                    "brandContains": {
                        "title": "Brand name contains",
                        "type": "string",
                        "description": "Keep only items whose brand name contains this text (case-insensitive)."
                    },
                    "inStockOnly": {
                        "title": "In-stock only",
                        "type": "boolean",
                        "description": "Drop items that are marked out of stock.",
                        "default": false
                    },
                    "onSaleOnly": {
                        "title": "On sale only",
                        "type": "boolean",
                        "description": "Keep only items currently discounted from their regular price (has a `regularPrice` higher than `price`).",
                        "default": false
                    },
                    "minRating": {
                        "title": "Min rating (0-5)",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Drop items with an average customer rating below this (out of 5). Items without a public rating are kept (unknown, not zero)."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Instacart's storefront does not require a proxy in most regions; enable the free Apify datacenter proxy if you see repeated 429/403 responses.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
