# Party City Scraper (`crawlerbros/party-city-scraper`) Actor

Scrape party supplies, balloons, costumes, and seasonal decor from partycity.com. Browse by category, search by keyword, or look up specific products. Get price, sale price, brand, and variant options like color/size/theme. No login, no proxy required.

- **URL**: https://apify.com/crawlerbros/party-city-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Agents, Automation, E-commerce
- **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/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

## Party City Scraper

Scrape **Party City** — the online retailer for party supplies, balloons, costumes, tableware, and seasonal decor. Browse any category, search by keyword, look up specific products by handle/URL, or list the entire live collection/category taxonomy. Get price, sale price, discount percentage, brand, variant options (color/size/theme), images, and image dimensions. No login, no proxy required.

### What this actor does

- **Four modes:** `byCategory` (paginated category browse), `search` (keyword search), `byHandles` (direct product lookup), `listCollections` (every live collection/category on the storefront, for discovery)
- **58 built-in categories** in the dropdown — birthday themes, licensed characters (Disney, Marvel, Star Wars, etc.), balloons, tableware, decorations, costumes, and special occasions — plus a free-text override for any other category, or use `listCollections` to discover the full live list (140+) dynamically
- **Price tracking:** current price, original (compare-at) price, computed discount percentage, on-sale flag
- **14 filter dimensions:** price range, brand, product type (substring or exact-match dropdown of 61 known types), title keyword, tags, SKU, stock status, discount %
- **Sorting:** best-selling (real ranking via Shopify's Storefront GraphQL API, since the legacy REST feed ignores sort entirely), price, title, or newest/oldest (all applied client-side for accuracy)
- **Empty fields are omitted** — every field present in a record has real data

### Output per product

- `productId`, `handle`, `productUrl` — canonical Party City product page
- `title`, `brand`, `productType`, `category`, `tags[]`
- `description` — plain text (HTML stripped)
- `price`, `maxPrice` — lowest / highest variant price
- `comparePrice`, `onSale`, `discountPercent` — sale tracking
- `currency` — always `USD`
- `variantCount`, `availableVariantCount`, `available`
- `skus[]` — up to 20
- `variants[]` — up to 30, each with `variantTitle`, `sku`, `price`, `comparePrice`, `available`, `variantImageUrl` (photo for that specific color/size when Party City provides one), and option values (color/size/theme)
- `imageUrl`, `images[]` — up to 15; `imageWidth`, `imageHeight` — pixel dimensions of the primary image
- `options[]` — variant option names/values (e.g. color, size, character theme)
- `createdAt`, `updatedAt`, `publishedAt`
- `recordType: "product"`, `scrapedAt`

### Output per collection (mode = listCollections)

- `collectionId`, `handle`, `collectionUrl` — canonical Party City collection page
- `title`, `description` — plain text (HTML stripped)
- `productsCount` — number of products currently in the collection
- `imageUrl`, `imageAlt` — collection banner image
- `updatedAt`, `publishedAt`
- `recordType: "collection"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byCategory` | `byCategory` / `search` / `byHandles` / `listCollections` |
| `category` | string | `birthday` | Category dropdown (mode=byCategory) |
| `categoryHandle` | string | – | Custom category handle override |
| `searchQuery` | string | – | Keyword search (mode=search), top 10 results |
| `productHandles` | array | – | Product handles or URLs (mode=byHandles) |
| `sortBy` | string | `best-selling` | Sort order for category browse |
| `maxItems` | int | `100` | Hard cap (1–10000) — also caps `listCollections` |
| `imageQuality` | string | `master` | Shopify CDN image size |
| `minPrice` / `maxPrice` | number | – | Price range filter (USD) |
| `onSaleOnly` | bool | `false` | Only discounted products |
| `minDiscountPercent` | int | – | Minimum discount % |
| `brandContains` | string | – | Brand name substring filter |
| `productTypeContains` | string | – | Product type substring filter |
| `productTypeEquals` | string | – | Product type exact-match dropdown (61 known types, e.g. `Costumes`, `Balloons`, `Plates`) |
| `titleContains` | string | – | Title substring filter |
| `tagAnyOf` / `tagNoneOf` | array | – | Tag allow/block list |
| `skuContains` | string | – | SKU substring filter |
| `includeUnavailable` | bool | `false` | Include out-of-stock products |
| `useApifyProxy` | bool | `false` | Force Apify proxy from the start |
| `requestDelaySecs` | int | `1` | Delay between page fetches |

#### Example: browse a category

```json
{
  "mode": "byCategory",
  "category": "birthday",
  "maxItems": 100,
  "sortBy": "best-selling"
}
````

#### Example: on-sale Halloween costumes

```json
{
  "mode": "byCategory",
  "category": "halloween-costumes",
  "onSaleOnly": true,
  "minDiscountPercent": 20,
  "maxItems": 200
}
```

#### Example: search by keyword

```json
{
  "mode": "search",
  "searchQuery": "balloon arch kit"
}
```

#### Example: look up specific products

```json
{
  "mode": "byHandles",
  "productHandles": [
    "https://www.partycity.com/products/colorful-collage-paper-plate-8ct"
  ]
}
```

#### Example: discover every collection/category

```json
{
  "mode": "listCollections",
  "maxItems": 200
}
```

#### Example: exact product-type filter

```json
{
  "mode": "byCategory",
  "category": "halloween-costumes",
  "productTypeEquals": "Costumes",
  "maxItems": 100
}
```

### Use cases

- **Price tracking** — monitor a category or theme for sale prices and discount depth
- **Seasonal planning** — pull current inventory/pricing ahead of Halloween, graduation, or birthday seasons
- **Market research** — analyze party-supply pricing and licensed-character assortment
- **Affiliate content** — pull current pricing/availability for party-planning guides
- **Competitive intelligence** — compare Party City pricing against other party/costume retailers

### FAQ

**Is this affiliated with Party City?**
No. This is a third-party actor that reads Party City's public storefront data — no login required.

**Why does `search` only return up to 10 results?**
Party City's in-store search runs on Shopify's predictive-search API, which caps relevance results at 10 by platform design. For larger result sets, use `byCategory` browse with `titleContains` to filter by keyword within a category.

**Why does `byCategory` sometimes deliver fewer products than a collection's `productsCount`?**
`byCategory` paginates `/collections/<handle>/products.json` until either `maxItems` is reached or the storefront returns a genuinely empty page — it never stops early on a short page. For most collections this reaches the collection's own reported `productsCount` exactly. A few large collections (e.g. `party-supplies`) are an exception: Party City's storefront JSON feed itself only ever serves a subset of the products counted in the collection's metadata (the rest are catalog-linked but not published to the JSON feed — visiting further pages returns `{"products":[]}` well before the metadata count is reached). This is a source-side data gap, not a scraper limitation — the actor already delivers every product Party City's public API exposes for that category.

**Why are some fields missing from a product?**
Fields are only included when Party City's storefront actually returns that data. For example, `comparePrice`/`discountPercent` only appear on discounted products, and `maxPrice` only appears when variants (e.g. size/color options) have different prices.

**What do the `options`/`variants` fields represent?**
Party City products often come in multiple options — color, size, or character theme (e.g. "Lunch" vs "Dessert" plates, or costume sizes). Each combination is a separate variant with its own price and stock status. When Party City has a distinct photo for a specific option (e.g. a costume size), it appears as `variantImageUrl` on that variant.

**What's the difference between `productTypeContains` and `productTypeEquals`?**
`productTypeContains` matches any product type containing your text as a substring. `productTypeEquals` is a dropdown of the 61 exact product types Party City uses catalog-wide (e.g. `Balloons`, `Costumes`, `Plates`) — use it when you want only that exact category, not a broader match.

**What does `listCollections` return?**
Every live collection/category on partycity.com — over 140 at any given time — with title, description, product count, and banner image. Use it to discover category handles beyond the 58 built into the `category` dropdown, then feed a handle into `categoryHandle` for `byCategory` mode.

**How fresh is the data?**
Every run fetches live data directly from partycity.com at request time.

**Does this actor require a proxy?**
No. Party City's storefront JSON endpoints are publicly accessible from standard datacenter IPs. The actor automatically retries via Apify proxy if a request is ever blocked.

# Actor input Schema

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

`byCategory` browses a category with full pagination. `search` runs Party City's in-store search (top 10 most relevant matches). `byHandles` looks up specific products by handle or URL. `listCollections` returns every live collection/category on the storefront (title, description, image, product count) for discovery.

## `category` (type: `string`):

A Party City category to browse. Covers birthday themes, balloons, tableware, decorations, costumes, and special occasions.

## `categoryHandle` (type: `string`):

Advanced: any Party City collection handle not in the dropdown above (the last segment of `partycity.com/collections/<handle>`). Overrides `category` when set.

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

Free-text keyword search, e.g. `birthday candle`, `pinata`, `balloon arch`. Returns Party City's top 10 most relevant matches (a platform limit on predictive search).

## `productHandles` (type: `array`):

Exact product handles (e.g. `colorful-collage-paper-plate-8ct`) or full product URLs. Looked up individually.

## `sortBy` (type: `string`):

Sort order applied to category browse results.

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

Hard cap on the number of products (or collections, for mode=listCollections) returned (1-10000).

## `imageQuality` (type: `string`):

Shopify CDN serves multiple image sizes. `master` returns the original.

## `minPrice` (type: `number`):

Drop products whose lowest price is below this threshold.

## `maxPrice` (type: `number`):

Drop products whose lowest price is above this threshold.

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

Only emit products with an active discount (compare-at price higher than the current price).

## `minDiscountPercent` (type: `integer`):

Only emit products discounted by at least this percentage.

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

Only emit products whose brand name contains this substring (case-insensitive).

## `productTypeContains` (type: `string`):

Only emit products whose Shopify product type contains this substring.

## `productTypeEquals` (type: `string`):

Only emit products whose Shopify product type exactly matches this value. Covers every product type observed across Party City's full catalog. Leave as "Any" to disable, or use `productTypeContains` for a substring match instead.

## `titleContains` (type: `string`):

Only emit products whose title contains this substring (case-insensitive).

## `tagAnyOf` (type: `array`):

Only emit products whose tags contain at least one of these (case-insensitive substring match).

## `tagNoneOf` (type: `array`):

Drop products whose tags contain any of these substrings.

## `skuContains` (type: `string`):

Only emit products with a SKU containing this substring.

## `includeUnavailable` (type: `boolean`):

When false (default), drop products that are entirely out of stock.

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

Route requests through Apify proxy from the start. Party City usually works from datacenter IPs without proxy — the actor automatically falls back to Apify proxy on the first failure regardless of this setting.

## `requestDelaySecs` (type: `integer`):

Pause between successive page fetches. Lower = faster, higher = more polite.

## Actor input object example

```json
{
  "mode": "byCategory",
  "category": "birthday",
  "productHandles": [],
  "sortBy": "best-selling",
  "maxItems": 20,
  "imageQuality": "master",
  "onSaleOnly": false,
  "productTypeEquals": "",
  "tagAnyOf": [],
  "tagNoneOf": [],
  "includeUnavailable": false,
  "useApifyProxy": false,
  "requestDelaySecs": 1
}
```

# 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": "byCategory",
    "category": "birthday",
    "productHandles": [],
    "sortBy": "best-selling",
    "maxItems": 20,
    "imageQuality": "master",
    "onSaleOnly": false,
    "productTypeEquals": "",
    "tagAnyOf": [],
    "tagNoneOf": [],
    "includeUnavailable": false,
    "useApifyProxy": false,
    "requestDelaySecs": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/party-city-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": "byCategory",
    "category": "birthday",
    "productHandles": [],
    "sortBy": "best-selling",
    "maxItems": 20,
    "imageQuality": "master",
    "onSaleOnly": False,
    "productTypeEquals": "",
    "tagAnyOf": [],
    "tagNoneOf": [],
    "includeUnavailable": False,
    "useApifyProxy": False,
    "requestDelaySecs": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/party-city-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": "byCategory",
  "category": "birthday",
  "productHandles": [],
  "sortBy": "best-selling",
  "maxItems": 20,
  "imageQuality": "master",
  "onSaleOnly": false,
  "productTypeEquals": "",
  "tagAnyOf": [],
  "tagNoneOf": [],
  "includeUnavailable": false,
  "useApifyProxy": false,
  "requestDelaySecs": 1
}' |
apify call crawlerbros/party-city-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Party City Scraper",
        "description": "Scrape party supplies, balloons, costumes, and seasonal decor from partycity.com. Browse by category, search by keyword, or look up specific products. Get price, sale price, brand, and variant options like color/size/theme. No login, no proxy required.",
        "version": "1.0",
        "x-build-id": "ULjT8tGZ3INqEbZQy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~party-city-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-party-city-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~party-city-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-party-city-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~party-city-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-party-city-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",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "byCategory",
                            "search",
                            "byHandles",
                            "listCollections"
                        ],
                        "type": "string",
                        "description": "`byCategory` browses a category with full pagination. `search` runs Party City's in-store search (top 10 most relevant matches). `byHandles` looks up specific products by handle or URL. `listCollections` returns every live collection/category on the storefront (title, description, image, product count) for discovery.",
                        "default": "byCategory"
                    },
                    "category": {
                        "title": "Category (mode = byCategory)",
                        "enum": [
                            "birthday",
                            "kids-birthday",
                            "preschooler-birthday",
                            "milestone-birthday",
                            "1st-birthday-party-supplies-decorations",
                            "sweet-16-party-supplies-decorations",
                            "happy-birthday-party-supplies",
                            "birthday-party-kits",
                            "balloons",
                            "balloon-bouquets-for-birthdays-celebrations",
                            "birthday-balloons-for-every-celebration",
                            "barbie-party-supplies-decorations",
                            "batman-party-supplies-decorations",
                            "dc-comic-party-supplies",
                            "disney-princess-party-supplies",
                            "dragon-party-supplies-decorations",
                            "frozen-party-supplies",
                            "gamer-party-supplies-video-game-birthday-decorations",
                            "harry-potter-party-supplies-decorations",
                            "marvel-party-supplies",
                            "spider-man-party-supplies-decorations",
                            "star-wars-party-supplies-decorations",
                            "superman-party-supplies-decorations",
                            "toy-story-party-supplies",
                            "bluey-party-supplies-decorations",
                            "construction-party-supplies-decorations",
                            "dinosaur-theme-party",
                            "hot-wheels-party-supplies-decorations",
                            "mickey-mouse-party-supplies-decorations",
                            "minnie-mouse-birthday-party-supplies-decorations",
                            "stitch-party-supplies-decorations",
                            "winnie-the-pooh-party-supplies",
                            "party-supplies",
                            "tableware",
                            "party-cups-for-every-celebration",
                            "party-napkins-disposable-napkins",
                            "party-plates-for-every-celebration",
                            "party-table-covers-tablecloths",
                            "decorations",
                            "party-favors",
                            "gifts-collectables",
                            "special-occasion",
                            "graduation",
                            "gender-reveal",
                            "baby-shower",
                            "bachelorette",
                            "wedding-bridal-shower",
                            "wedding-anniversary",
                            "retirement",
                            "100-days-of-school",
                            "same-day-delivery-party-supplies",
                            "halloween-costumes",
                            "kid-costumes",
                            "baby-costumes",
                            "adult-halloween-costumes",
                            "dog-pet-costumes",
                            "costume-themes",
                            "costume-accessories"
                        ],
                        "type": "string",
                        "description": "A Party City category to browse. Covers birthday themes, balloons, tableware, decorations, costumes, and special occasions.",
                        "default": "birthday"
                    },
                    "categoryHandle": {
                        "title": "Custom category handle (optional override)",
                        "type": "string",
                        "description": "Advanced: any Party City collection handle not in the dropdown above (the last segment of `partycity.com/collections/<handle>`). Overrides `category` when set."
                    },
                    "searchQuery": {
                        "title": "Search query (mode = search)",
                        "type": "string",
                        "description": "Free-text keyword search, e.g. `birthday candle`, `pinata`, `balloon arch`. Returns Party City's top 10 most relevant matches (a platform limit on predictive search)."
                    },
                    "productHandles": {
                        "title": "Product handles or URLs (mode = byHandles)",
                        "type": "array",
                        "description": "Exact product handles (e.g. `colorful-collage-paper-plate-8ct`) or full product URLs. Looked up individually.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort by (mode = byCategory)",
                        "enum": [
                            "best-selling",
                            "manual",
                            "price-ascending",
                            "price-descending",
                            "title-ascending",
                            "title-descending",
                            "created-ascending",
                            "created-descending"
                        ],
                        "type": "string",
                        "description": "Sort order applied to category browse results.",
                        "default": "best-selling"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard cap on the number of products (or collections, for mode=listCollections) returned (1-10000).",
                        "default": 20
                    },
                    "imageQuality": {
                        "title": "Image URL quality",
                        "enum": [
                            "small",
                            "medium",
                            "large",
                            "grande",
                            "1024x1024",
                            "2048x2048",
                            "master"
                        ],
                        "type": "string",
                        "description": "Shopify CDN serves multiple image sizes. `master` returns the original.",
                        "default": "master"
                    },
                    "minPrice": {
                        "title": "Min price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "number",
                        "description": "Drop products whose lowest price is below this threshold."
                    },
                    "maxPrice": {
                        "title": "Max price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "number",
                        "description": "Drop products whose lowest price is above this threshold."
                    },
                    "onSaleOnly": {
                        "title": "On-sale products only",
                        "type": "boolean",
                        "description": "Only emit products with an active discount (compare-at price higher than the current price).",
                        "default": false
                    },
                    "minDiscountPercent": {
                        "title": "Min discount %",
                        "minimum": 0,
                        "maximum": 99,
                        "type": "integer",
                        "description": "Only emit products discounted by at least this percentage."
                    },
                    "brandContains": {
                        "title": "Brand contains",
                        "type": "string",
                        "description": "Only emit products whose brand name contains this substring (case-insensitive)."
                    },
                    "productTypeContains": {
                        "title": "Product type contains",
                        "type": "string",
                        "description": "Only emit products whose Shopify product type contains this substring."
                    },
                    "productTypeEquals": {
                        "title": "Product type (exact match)",
                        "enum": [
                            "",
                            "Animated Props",
                            "Apparel",
                            "Arts & Crafts",
                            "Awards, Medals, Trophies",
                            "Backdrops & Scene Setters",
                            "Baking Supplies",
                            "Balloons",
                            "Banners & Signs",
                            "Birthday Candles",
                            "Bowls",
                            "Cake Toppers & Picks",
                            "Chocolates",
                            "Cleaning & Disposal Supplies",
                            "Confetti & Streamers",
                            "Coolers & Beverage Tubs",
                            "Costume Accessories",
                            "Costumes",
                            "Cutlery",
                            "Decorating Kits",
                            "Decorations",
                            "Drinkware",
                            "Favor Bags & Containers",
                            "Favor Kits",
                            "Favors",
                            "Fog & Bubble Machines",
                            "Games",
                            "Gift Bags",
                            "Gift Boxes",
                            "Gift Tags & Labels",
                            "Gift Wrap & Tissue Paper",
                            "Gloves",
                            "Glow Sticks & Accessories",
                            "Hanging Decorations",
                            "Hats",
                            "Headband",
                            "Home Decor",
                            "Inflatable Decorations",
                            "Invitations, Announcements, & Greeting Cards",
                            "Keepsakes & Gifts",
                            "Lights",
                            "Makeup & Face Paint",
                            "Napkins",
                            "Outdoor Games",
                            "Party Kits",
                            "Party Supplies",
                            "Pet Toys & Accessories",
                            "Photo Booth Props",
                            "Piñatas",
                            "Plates",
                            "Props & Standees",
                            "Serveware",
                            "Serving Trays & Bowls",
                            "Skirt",
                            "Snacks & Treats",
                            "Straws",
                            "T-Shirt",
                            "Tablecovers",
                            "Tabletop Decorations",
                            "Toys",
                            "Wigs",
                            "Yard Decorations & Signs"
                        ],
                        "type": "string",
                        "description": "Only emit products whose Shopify product type exactly matches this value. Covers every product type observed across Party City's full catalog. Leave as \"Any\" to disable, or use `productTypeContains` for a substring match instead.",
                        "default": ""
                    },
                    "titleContains": {
                        "title": "Title contains",
                        "type": "string",
                        "description": "Only emit products whose title contains this substring (case-insensitive)."
                    },
                    "tagAnyOf": {
                        "title": "Tag allowlist (any of)",
                        "type": "array",
                        "description": "Only emit products whose tags contain at least one of these (case-insensitive substring match).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "tagNoneOf": {
                        "title": "Tag blocklist",
                        "type": "array",
                        "description": "Drop products whose tags contain any of these substrings.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "skuContains": {
                        "title": "SKU contains",
                        "type": "string",
                        "description": "Only emit products with a SKU containing this substring."
                    },
                    "includeUnavailable": {
                        "title": "Include out-of-stock products",
                        "type": "boolean",
                        "description": "When false (default), drop products that are entirely out of stock.",
                        "default": false
                    },
                    "useApifyProxy": {
                        "title": "Use Apify proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify proxy from the start. Party City usually works from datacenter IPs without proxy — the actor automatically falls back to Apify proxy on the first failure regardless of this setting.",
                        "default": false
                    },
                    "requestDelaySecs": {
                        "title": "Delay between page fetches (seconds)",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Pause between successive page fetches. Lower = faster, higher = more polite.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
