# Walgreens Product Catalog Scraper (`automation-lab/walgreens-product-catalog-scraper`) Actor

🛍️ Extract Walgreens catalog products with normalized prices, promotions, ratings, inventory, identifiers, images, and fulfillment options. Built for retail intelligence, price monitoring, and assortment analysis.

- **URL**: https://apify.com/automation-lab/walgreens-product-catalog-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 3 total users, 2 monthly users, 75.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Walgreens Product Catalog Scraper

Extract public Walgreens category catalogs into clean product records with prices, promotions, ratings, inventory, images, identifiers, and fulfillment options.

Use **Walgreens Product Catalog Scraper** when spreadsheets and manual category checks are too slow for recurring retail intelligence. Give it one or more Walgreens category URLs, choose a product limit, and receive a deduplicated dataset ready for analysis or automation.

- 🏷️ Compare regular, sale, and unit prices.
- 📦 Monitor online and store inventory signals.
- 🚚 Track same-day and shipping availability.
- ⭐ Collect ratings and review counts.
- 🔎 Join records using product ID, SKU, PLN, UPC, or GTIN.
- 🖼️ Export product and image URLs.

No Walgreens login is required for the public category pages supported by this Actor.

### What does Walgreens Product Catalog Scraper do?

The Actor downloads public Walgreens category and product-list pages, reads their embedded product catalog data, and creates one dataset row per product.

It follows Walgreens category pagination, stops at your configured limits, and removes duplicate product IDs across overlapping categories.

Each row includes the source page and observed Walgreens store context. That provenance matters because prices and fulfillment availability may vary by location.

The v1 product boundary is intentionally reliable and clear: public category and product-list URLs are supported. Product-detail URLs and thin search-result URLs are rejected instead of returning incomplete or misleading output.

### Who is it for?

#### CPG brand and category teams

Measure assortment, price positioning, promotional messages, ratings, and availability for your products and competitors.

#### Retail intelligence analysts

Build repeat snapshots of Walgreens categories for price indices, assortment changes, and fulfillment comparisons.

#### Resellers and e-commerce operators

Find in-stock products, promotion signals, sale prices, and shipping or same-day options for sourcing workflows.

#### Data engineers

Feed normalized Walgreens catalog rows into warehouses, dashboards, alerts, or enrichment pipelines through datasets, API clients, webhooks, and MCP.

#### Researchers

Export category observations to CSV, JSON, Excel, XML, or Parquet without manually copying product cards.

### Why use this Walgreens scraper?

- ⚡ **HTTP-first extraction** keeps runs fast and lightweight.
- 🧾 **Normalized numbers** turn price and rating strings into analysis-ready numeric values.
- 🧬 **Stable identifiers** help join repeated snapshots.
- 🗂️ **Broad catalog fields** cover merchandising, taxonomy, compliance, inventory, and fulfillment.
- 🔁 **Built-in deduplication** prevents overlapping category URLs from duplicating the same product.
- 📍 **Observed context** labels location-sensitive records instead of presenting them as universal.
- 🛑 **Fail-closed validation** rejects unsupported domains and page types.
- 📏 **Predictable limits** control pages and unique products independently.

### What Walgreens product data can I extract?

| Group | Fields |
| --- | --- |
| Identity | Product ID, SKU, DS SKU, article ID, PLN, UPC, GTIN |
| Product | Title, product name, product type, brand, brand ID, size |
| Categories | Level 1–3 category names and IDs |
| Pricing | Regular price, sale price, unit price, unit size, on-sale flag |
| Promotions | Offer text, rebate text, clearance flag |
| Ratings | Average rating and review count |
| Inventory | Online, selected-store, and network inventory status |
| Fulfillment | Same-day, shipping, delivery option, purchase limit |
| Features | Age restriction, FSA, WIC, web exclusive, loyalty, auto reorder |
| Media | Primary, 450px, and thumbnail images; product and quick-look URLs |
| Provenance | Source URL, source page, observed store, scrape timestamp |

Fields unavailable for a particular product are omitted rather than filled with invented values.

### How much does it cost to scrape Walgreens products?

The Actor uses pay-per-event pricing:

- A small one-time **Actor start** charge covers run setup.
- A **Walgreens product** event is charged for each product row saved.
- Tiered prices decrease on larger Apify plans.

The current source configuration starts at **$0.005 per run** plus a tiered per-product price. The exact live amount is always shown in the Apify Console before you start a run.

For example, a run limited to 25 products is billed for one start event and at most 25 product events. Products skipped as duplicates are not saved or charged as product results.

Apify Free plan credits may cover small evaluation runs. Set `maxItems` to 10 and `maxPages` to 1 for a cheap first test.

### How to scrape a Walgreens category

1. Open a public Walgreens category page in your browser.
2. Copy its URL, such as a URL ending in `-tier3`.
3. Open this Actor and click **Try for free**.
4. Paste the URL into **Walgreens category URLs**.
5. Set **Maximum products** and **Maximum pages per category**.
6. Keep proxying off unless direct access fails for your account or region.
7. Click **Start**.
8. Preview the **Walgreens products** dataset view.
9. Export results or connect the run to your downstream workflow.

### Input

```json
{
  "startUrls": [
    {
      "url": "https://www.walgreens.com/store/c/shampoo-and-conditioner/ID%3D360481-tier3"
    }
  ],
  "maxItems": 25,
  "maxPages": 1,
  "useApifyProxy": false
}
````

| Input | Type | Default | Purpose |
| --- | --- | --- | --- |
| `startUrls` | array | required | Public Walgreens category or product-list URLs |
| `maxItems` | integer | `25` | Global maximum unique products |
| `maxPages` | integer | `3` | Maximum pages fetched per input URL |
| `useApifyProxy` | boolean | `false` | Route requests through Apify Proxy |
| `proxyGroups` | string array | empty | Optional proxy groups when proxying is enabled |

`maxItems` is global. If several input categories overlap, the Actor continues until it reaches the unique-product limit or exhausts the configured pages.

### Supported Walgreens URLs

Supported examples:

```text
https://www.walgreens.com/store/c/shampoo-and-conditioner/ID%3D360481-tier3
https://www.walgreens.com/store/store/category/productlist.jsp?N=360481&Eon=360481
```

The Actor accepts HTTPS URLs on `walgreens.com` subdomains when their paths identify public tier-3 category or product-list pages.

It rejects:

- Product-detail URLs ending in `-product`.
- Generic search-result pages.
- URLs on non-Walgreens domains.
- Pages without a complete embedded product catalog.

This scope avoids silently mixing catalog cards with a different entity shape.

### Output example

```json
{
  "productId": "300397797",
  "skuId": "400618842",
  "dsSkuId": "618842",
  "pln": "40000842396",
  "gtin": "49022400696",
  "title": "Walgreens Medicated Dandruff Shampoo with Menthol / Selenium Sulfide 1%",
  "brand": "Walgreens",
  "productSize": "11 fl oz",
  "categoryLevel1": "Beauty",
  "categoryLevel2": "Hair Care",
  "categoryLevel3": "Shampoo & Conditioner",
  "regularPrice": 7.49,
  "unitPrice": 0.68,
  "unitPriceSize": "oz",
  "rating": 4,
  "reviewCount": 89,
  "onlineInventoryStatus": "instock",
  "sameDayEnabled": true,
  "shippingEnabled": true,
  "productUrl": "https://www.walgreens.com/store/c/.../ID=300397797-product",
  "observedStoreAddress": "151 N STATE ST, CHICAGO",
  "sourcePage": 1,
  "scrapedAt": "2026-07-21T00:00:00.000Z"
}
```

Numeric values are emitted as numbers. Identifiers remain strings so leading zeroes are preserved.

### Pagination and deduplication

Walgreens category pages expose a page summary and a product list. The Actor advances through pages using the public catalog offset and stops when one of these conditions is met:

- `maxItems` unique products have been saved.
- `maxPages` pages have been fetched for that category.
- Walgreens reports the last page.
- A page fails after bounded retries.

Products are deduplicated by Walgreens product ID across all input URLs. This is useful when tracking related or filtered categories with shared products.

### Price and availability context

Walgreens can select a store context for an anonymous visitor. The same product may have different inventory, fulfillment, or promotional values elsewhere.

Use these fields when interpreting a record:

- `observedStoreId`
- `observedStoreAddress`
- `sourceUrl`
- `sourcePage`
- `scrapedAt`

Treat each run as an observation, not a guarantee of universal price or stock. For time-series monitoring, keep the provenance fields in every snapshot.

### Tips for reliable runs

- 🎯 Start with one category and 10 products.
- 📄 Increase `maxPages` only when you need deeper catalog coverage.
- 🔁 Schedule consistent inputs to compare snapshots over time.
- 🧬 Join snapshots by `productId` or `gtin`, not title.
- 📍 Keep observed store fields in analytics tables.
- 🌐 Enable Apify Proxy only if direct requests fail or your workflow needs another network location.
- 🧹 Expect optional fields to be absent for products where Walgreens does not expose them.
- ⏱️ Use webhooks instead of polling long scheduled runs.

### Integrations and automation workflows

#### Google Sheets and Excel

Export a dataset to CSV or Excel for category review, promotion tracking, and reseller shortlists.

#### Data warehouses

Load JSON or Parquet into BigQuery, Snowflake, Redshift, or PostgreSQL. Use `productId` plus `scrapedAt` as a snapshot key.

#### Price and stock alerts

Run the Actor on a schedule, compare the latest dataset with the previous snapshot, and notify Slack or email when price or availability changes.

#### Business intelligence

Connect product snapshots to Looker Studio, Tableau, Power BI, or Metabase for category dashboards.

#### Webhooks and automation platforms

Send run-completion webhooks to Make, Zapier, n8n, or your own endpoint, then fetch the default dataset.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/walgreens-product-catalog-scraper').call({
  startUrls: [{
    url: 'https://www.walgreens.com/store/c/shampoo-and-conditioner/ID%3D360481-tier3',
  }],
  maxItems: 25,
  maxPages: 1,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Install the client with `npm install apify-client`.

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/walgreens-product-catalog-scraper').call(run_input={
    'startUrls': [{
        'url': 'https://www.walgreens.com/store/c/shampoo-and-conditioner/ID%3D360481-tier3'
    }],
    'maxItems': 25,
    'maxPages': 1,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Install the client with `pip install apify-client`.

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~walgreens-product-catalog-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{
      "url": "https://www.walgreens.com/store/c/shampoo-and-conditioner/ID%3D360481-tier3"
    }],
    "maxItems": 25,
    "maxPages": 1
  }'
```

Read the returned run object, wait for completion, and fetch items from its `defaultDatasetId`.

### Use Walgreens Product Catalog Scraper with MCP

Apify MCP lets AI tools run this Actor and read its datasets.

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/walgreens-product-catalog-scraper"
```

For Claude Desktop, Cursor, or VS Code, add an HTTP MCP server:

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/walgreens-product-catalog-scraper"
    }
  }
}
```

Example prompts:

- “Extract 25 shampoo products from this Walgreens category and rank them by unit price.”
- “Compare regular and sale prices, then flag products with shipping but no same-day fulfillment.”
- “Create a CSV-ready table of GTIN, brand, rating, review count, and stock status.”

### Scheduling a Walgreens catalog monitor

1. Save a task with stable category URLs and limits.
2. Add a daily or weekly schedule in Apify Console.
3. Keep each run dataset as a timestamped snapshot.
4. Compare rows by `productId` or `gtin`.
5. Trigger a webhook when the run finishes.
6. Notify downstream users only after checking the observed store context.

For large catalogs, increase pages gradually and verify that the resulting frequency fits your budget.

### Is it legal to scrape Walgreens?

This Actor extracts publicly accessible product catalog information. Scraping legality depends on your location, purpose, contract, and the data you collect.

You are responsible for:

- Following applicable laws and Walgreens terms.
- Using reasonable run frequency and limits.
- Avoiding personal or restricted data.
- Respecting intellectual-property and database rights.
- Applying retention and access controls appropriate to your workflow.

This information is not legal advice. Consult qualified counsel for high-risk or regulated uses.

### Limitations

- v1 supports category and product-list pages, not generic search or product-detail pages.
- Anonymous store selection may vary by request location.
- Walgreens can change embedded state fields or page delivery without notice.
- Optional values differ by category and product.
- Promotions and inventory are snapshots and may change quickly.
- The Actor does not place orders, log in, redeem coupons, or guarantee stock.
- Proxy location is not an explicit store selector.

### Troubleshooting

#### The Actor says my URL is unsupported

Use a public Walgreens category URL ending in `-tier3` or a Walgreens product-list URL. Do not submit a product detail, broad tier-1/tier-2 landing page, or generic search page.

#### The Actor extracted no products

Open the source URL manually and confirm it is still a product category. Check the run log for HTTP status or embedded-state errors. Retry with a small limit; if direct delivery is blocked in your region, enable Apify Proxy.

#### Prices differ from my browser

Compare `observedStoreId` and `observedStoreAddress`. Walgreens can return store-dependent price and availability context.

#### I received fewer rows than `maxItems`

The category may contain fewer products, your `maxPages` may be reached first, or overlapping input categories may contain duplicate product IDs.

### Frequently asked questions

#### Does the Actor need my Walgreens account?

No. The supported category catalog is public and anonymous.

#### Can I scrape several categories in one run?

Yes. Add multiple URLs to `startUrls`. The global `maxItems` limit and product-ID deduplication apply across all of them.

#### Are prices numeric?

Yes. Regular, sale, and unit prices are normalized to numbers when Walgreens exposes them.

#### Can I select a ZIP code?

Not in v1. The Actor reports the store context observed in the public response rather than pretending that proxy geography equals an explicit ZIP/store selection.

#### Does it scrape reviews?

It extracts average rating and review count from catalog cards. It does not emit individual review records.

#### Can I export to CSV or Excel?

Yes. Use the Dataset export controls or API endpoints after the run.

### Related retail scrapers

- [Walmart Scraper](https://apify.com/automation-lab/walmart-scraper) — collect Walmart product and price data.
- [Amazon Scraper](https://apify.com/automation-lab/amazon-scraper) — extract Amazon product listings and details.
- [Google Shopping Scraper](https://apify.com/automation-lab/google-shopping-scraper) — compare shopping offers across merchants.

Combine source-specific snapshots by GTIN, UPC, brand, or normalized title to build broader retail intelligence workflows.

### Support

For reproducible support requests, include:

- The Actor run URL.
- A redacted copy of the input.
- The Walgreens category URL.
- Expected and actual product counts.
- One affected product ID when applicable.

Do not include Apify tokens, private credentials, or unrelated personal data.

# Actor input Schema

## `startUrls` (type: `array`):

Add public Walgreens category or product-list URLs. Product-detail and search URLs are not supported in v1.

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

Stop after this many unique products across all category URLs.

## `maxPages` (type: `integer`):

Limit pagination for each category. Walgreens pages currently contain up to 72 products.

## `useApifyProxy` (type: `boolean`):

Enable Apify Proxy if direct access is unavailable or you need a different network location.

## `proxyGroups` (type: `array`):

Optional Apify Proxy groups, for example RESIDENTIAL. Leave empty to use the account default.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.walgreens.com/store/c/shampoo-and-conditioner/ID%3D360481-tier3"
    }
  ],
  "maxItems": 10,
  "maxPages": 1,
  "useApifyProxy": false,
  "proxyGroups": []
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.walgreens.com/store/c/shampoo-and-conditioner/ID%3D360481-tier3"
        }
    ],
    "maxItems": 10,
    "maxPages": 1,
    "useApifyProxy": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/walgreens-product-catalog-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 = {
    "startUrls": [{ "url": "https://www.walgreens.com/store/c/shampoo-and-conditioner/ID%3D360481-tier3" }],
    "maxItems": 10,
    "maxPages": 1,
    "useApifyProxy": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/walgreens-product-catalog-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 '{
  "startUrls": [
    {
      "url": "https://www.walgreens.com/store/c/shampoo-and-conditioner/ID%3D360481-tier3"
    }
  ],
  "maxItems": 10,
  "maxPages": 1,
  "useApifyProxy": false
}' |
apify call automation-lab/walgreens-product-catalog-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/walgreens-product-catalog-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Walgreens Product Catalog Scraper",
        "description": "🛍️ Extract Walgreens catalog products with normalized prices, promotions, ratings, inventory, identifiers, images, and fulfillment options. Built for retail intelligence, price monitoring, and assortment analysis.",
        "version": "0.1",
        "x-build-id": "YkGIy2Es5hZYYAWxJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~walgreens-product-catalog-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-walgreens-product-catalog-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/automation-lab~walgreens-product-catalog-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-walgreens-product-catalog-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/automation-lab~walgreens-product-catalog-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-walgreens-product-catalog-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🛍️ Walgreens category URLs",
                        "type": "array",
                        "description": "Add public Walgreens category or product-list URLs. Product-detail and search URLs are not supported in v1.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "📦 Maximum products",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many unique products across all category URLs.",
                        "default": 25
                    },
                    "maxPages": {
                        "title": "📄 Maximum pages per category",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Limit pagination for each category. Walgreens pages currently contain up to 72 products.",
                        "default": 3
                    },
                    "useApifyProxy": {
                        "title": "🌐 Use Apify Proxy",
                        "type": "boolean",
                        "description": "Enable Apify Proxy if direct access is unavailable or you need a different network location.",
                        "default": false
                    },
                    "proxyGroups": {
                        "title": "Proxy groups",
                        "type": "array",
                        "description": "Optional Apify Proxy groups, for example RESIDENTIAL. Leave empty to use the account default.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```