# Faire Product & Brand Details Scraper (`automation-lab/faire-product-brand-details-scraper`) Actor

🛍️ Turn supplied public Faire product URLs into sourcing-ready stock, retail-price, MOQ, option, image, orderability, lead-time, rating, review, and brand minimum records.

- **URL**: https://apify.com/automation-lab/faire-product-brand-details-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.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

## Faire Product & Brand Details Scraper

Turn public Faire product pages into structured wholesale sourcing records.

Paste one or many `faire.com/product/p_...` URLs and receive one normalized row per product with retail price, stock, MOQ, case-pack rules, images, option state, brand minimums, lead time, rating, and review count.

This Actor is designed for retailers, sourcing teams, catalog operators, and analysts who already have product-detail URLs and need repeatable data instead of manual copying.

- 🛍️ Extract product and primary-option details
- 📦 Compare minimums, multipliers, pre-packs, and orderability
- 🏬 Enrich records with brand economics and reputation
- 🔁 Schedule recurring stock, price, and lead-time checks
- 📤 Export to JSON, CSV, Excel, Google Sheets, or your API workflow

### What does Faire Product & Brand Details Scraper do?

The scraper visits each supplied public Faire product-detail page and reads the server-rendered product and brand state.

It creates one product record for every successfully processed unique product token.

The output combines product identity, merchandising content, wholesale order rules, the primary active option, stock availability, and brand-level details.

It does not require a Faire buyer account, Faire API key, or browser automation for the supported public pages.

This version intentionally accepts product-detail URLs only.

It does not claim Faire search, category, brand-page, account-dashboard, or sitemap discovery.

### Who is it for?

#### Independent retailers

Compare suggested retail prices, minimum quantities, brand order minimums, and lead times before adding products to a buying shortlist.

#### Wholesale sourcing teams

Turn supplier research into consistent rows that can be sorted by availability, MOQ, rating, review count, or shipping origin.

#### PIM and catalog operators

Enrich internal product records with canonical Faire tokens, descriptions, image URLs, option identifiers, SKU values, measurements, and lifecycle state.

#### Market and assortment analysts

Build recurring snapshots of products already under review and detect changes in stock, orderability, price, or brand terms.

#### Automation developers

Call the Actor through the Apify API, webhooks, integrations, or MCP without maintaining Cloudflare-aware request and parsing logic.

### Why use this Faire scraper?

Manual sourcing reviews are slow and inconsistent.

Product pages mix consumer-facing content with wholesale economics, option state, and brand-level terms.

This Actor places those values in stable columns.

- ✅ Strict URL validation prevents unrelated Faire pages from producing misleading rows
- ✅ Duplicate product tokens are processed once
- ✅ Proxy sessions rotate after a challenge or incomplete response
- ✅ Total extraction failure exits non-zero instead of reporting false success
- ✅ One row per product makes monitoring and catalog joins predictable
- ✅ Numeric values remain numbers for filtering and calculations

### What Faire data can you extract?

| Group | Example fields | Why it matters |
|---|---|---|
| Identity | `canonicalUrl`, `productToken`, `title`, `category` | Join and deduplicate products |
| Content | `description`, `imageUrls`, `badges` | Enrich catalogs and merchandising reviews |
| Availability | `availableUnits`, `productState`, `brandAvailability` | Track whether a product can be ordered |
| Retail price | `retailPriceCents`, `currency` | Compare suggested retail economics |
| Product terms | `minOrderQuantity`, `unitMultiplier`, `perStyleMinOrderQuantity` | Estimate opening inventory |
| Pack rules | `hasPrePacksAvailable`, `soldInPrePacks` | Understand case and pre-pack handling |
| Option | `optionToken`, `optionName`, `optionSku`, `optionGtin` | Map the primary active option |
| Measurements | `weight`, `massUnit` | Support shipping and catalog workflows |
| Brand | `brandToken`, `brandName`, `brandPublishedProductsCount` | Group products by supplier |
| Brand minimum | `brandMinimumOrderCents`, `brandMinimumOrderCurrency` | Model supplier opening orders |
| Lead time | `brandLeadTimeDays`, lower and upper bounds | Plan replenishment timing |
| Reputation | `brandAverageRating`, `brandReviewCount` | Add supplier quality signals |
| Pricing flags | `hasVolumePricing` | Identify products with quantity pricing |
| Freshness | `scrapedAt` | Compare scheduled snapshots |

Optional source values are omitted when Faire does not publish them for that product.

### How much does it cost to scrape Faire product details?

This Actor uses pay-per-event pricing.

A $0.005 start event covers run setup, and an item event is charged only for each complete Faire product record saved to the dataset.

| Apify tier | Price per Faire product | 1,000 products plus start |
|---|---:|---:|
| Free | $0.00074073 | about $0.75 |
| Bronze | $0.00064411 | about $0.65 |
| Silver | $0.00050241 | about $0.51 |
| Gold | $0.00038647 | about $0.39 |
| Platinum | $0.00025765 | about $0.26 |
| Diamond | $0.00018035 | about $0.19 |

Proxy and compute usage are included in the Actor charge; you do not need to calculate separate infrastructure fees.

For the cheapest first test, keep the prefilled input at one product: about $0.00575 on the Free tier.

Before a larger monitoring job, estimate the maximum charge in Console using the number of supplied unique product tokens.

### How to scrape Faire products

1. Open the Actor input page.
2. Add one or more public URLs matching `https://www.faire.com/product/p_...`.
3. Set **Maximum products** to control the run size.
4. Keep the recommended SHADER US proxy unless you have a tested alternative.
5. Start the run.
6. Preview the **Faire products** dataset view.
7. Export the records or connect them to your downstream workflow.

A one-product run normally finishes well within the five-minute Actor timeout.

### Input parameters

| Parameter | Type | Required | Description |
|---|---|---:|---|
| `startUrls` | array | Yes | Public Faire product-detail URLs |
| `maxItems` | integer | No | Maximum unique products to save, from 1 to 1,000 |
| `maxRequestRetries` | integer | No | Proxy-session attempts per product, from 1 to 5 |
| `proxyConfiguration` | object | No | Apify Proxy or custom proxy configuration |

The recommended default proxy is Apify SHADER in the United States.

Do not paste search, category, brand, sitemap, login, or account URLs.

Unsupported URLs fail early with an actionable validation message.

### Input example

```json
{
  "startUrls": [
    { "url": "https://www.faire.com/product/p_8x9adp4dzv" }
  ],
  "maxItems": 1,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["SHADER"],
    "apifyProxyCountry": "US"
  }
}
````

You may also provide a URL as a plain string when calling the Actor through the API.

### Output example

```json
{
  "canonicalUrl": "https://www.faire.com/product/p_8x9adp4dzv",
  "productToken": "p_8x9adp4dzv",
  "title": "BIG sticker Suncatcher \"ex-voto flower\"",
  "category": "Suncatcher",
  "imageCount": 2,
  "shipsFrom": "Ships from France",
  "minOrderQuantity": 5,
  "unitMultiplier": 1,
  "availableUnits": 30,
  "retailPriceCents": 1500,
  "currency": "USD",
  "brandName": "Poulette Magique",
  "brandMinimumOrderCents": 10286,
  "brandLeadTimeDays": 15,
  "brandAverageRating": 5,
  "brandReviewCount": 7,
  "hasVolumePricing": false,
  "scrapedAt": "2026-07-18T04:58:09.317Z"
}
```

The complete record also contains description, image URLs, badges, option state, orderability, measurements, and lead-time bounds when available.

### Understanding prices and quantities

`retailPriceCents` is the public suggested retail amount in the accompanying `currency`.

For example, `1500` with `USD` means a retail price of USD 15.00.

`brandMinimumOrderCents` is the brand-level minimum in `brandMinimumOrderCurrency`.

`minOrderQuantity` is the product-level MOQ.

`optionMinOrderQuantity` applies to the primary active option.

`unitMultiplier` and `optionUnitMultiplier` help model how many units are added per cart quantity.

Wholesale buyer-only prices or private deal terms are not claimed by this Actor.

### Understanding options and availability

A Faire product can contain multiple options.

The Actor reports `optionCount` and flattens the first active, non-deleted option into stable option columns.

This keeps one chargeable row per supplied product and makes CSV exports usable.

Use `optionToken`, `optionSku`, and `optionGtin` to map the primary option.

Use `optionState`, `optionLifecycleState`, `brandAvailability`, and `orderabilityType` together when evaluating availability.

`availableUnits` reflects the public option value at scrape time and may change between runs.

### Tips for reliable recurring monitoring

- 🔁 Use the same canonical product URL set on every scheduled run
- 🕒 Store `scrapedAt` with each snapshot before comparing changes
- 🧮 Compare integer cent fields rather than formatted currency text
- 📦 Watch MOQ and multiplier changes alongside price changes
- 🏬 Group by `brandToken`, not only the display name
- ⚠️ Treat missing optional fields as unpublished source data, not zero
- 🎯 Keep concurrency conservative by using this URL-detail workflow
- 🌐 Retain the recommended proxy unless another route has been verified

### Integrations and workflow patterns

#### Google Sheets sourcing tracker

Schedule the Actor, send dataset rows to Google Sheets, and add buyer-review columns for margin, fit, and reorder priority.

#### Airtable product intake

Use `productToken` as an external identifier and update image, MOQ, stock, and brand fields after each run.

#### PIM enrichment

Join `canonicalUrl` or `productToken` to candidate products, then map descriptions, images, option SKU, and measurements into your PIM.

#### Stock and term monitoring

Store each run in a warehouse and alert when `availableUnits`, `retailPriceCents`, `minOrderQuantity`, or `brandLeadTimeDays` changes.

#### Supplier scorecard

Aggregate products by `brandToken` and combine minimum order, lead time, rating, review count, and catalog size.

#### Webhooks

Attach an Apify webhook to trigger your ETL or notification service when a scheduled run succeeds or fails.

### 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/faire-product-brand-details-scraper').call({
  startUrls: [{ url: 'https://www.faire.com/product/p_8x9adp4dzv' }],
  maxItems: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Use environment variables or a secret manager for your Apify token.

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/faire-product-brand-details-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.faire.com/product/p_8x9adp4dzv'}],
    'maxItems': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

The returned dataset can be loaded into pandas or written directly to your catalog pipeline.

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~faire-product-brand-details-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://www.faire.com/product/p_8x9adp4dzv"}],
    "maxItems": 1
  }'
```

After the run finishes, fetch items from its `defaultDatasetId`.

### Use with Apify MCP

Apify MCP lets Claude Code, Claude Desktop, Cursor, or VS Code call this Actor as a tool.

For Claude Code:

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

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

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/faire-product-brand-details-scraper"
    }
  }
}
```

Example prompts:

- “Extract the wholesale order terms from these Faire product URLs.”
- “Compare stock, MOQ, and lead time for my Faire sourcing shortlist.”
- “Return a CSV-ready table with Faire brand ratings and minimum orders.”

### Data quality and limitations

The Actor extracts public values available in Faire's server-rendered product state at run time.

Optional fields differ by product and brand.

The primary active option is flattened; additional option objects are not emitted as separate rows in v1.

Currency can depend on the public session geography and Faire's current presentation rules.

The Actor does not log in and cannot access buyer-only wholesale prices, private discounts, checkout data, or account dashboards.

Faire may change its page structure or anti-bot controls.

A total extraction failure makes the run fail so monitoring systems can detect the problem.

### Troubleshooting

#### The run says my URL is unsupported

Confirm the URL begins with `https://www.faire.com/product/p_` and contains a real public product token.

Remove search, category, brand, sitemap, referral, login, and dashboard URLs.

#### A product could not be extracted

Open the URL anonymously and confirm the product is still public.

Keep retries at the default value and use the recommended SHADER US proxy configuration.

If every URL fails, inspect the run log for HTTP challenge or embedded-state errors.

#### A field is missing

Faire does not publish every optional value for every product.

Missing is different from zero or false, so the Actor omits unavailable optional fields.

#### The same product was submitted twice

Duplicate product tokens are intentionally processed once to prevent duplicate rows and charges.

### Is scraping Faire legal?

This Actor accesses public product pages without logging in.

Scraping legality depends on your jurisdiction, purpose, contract, and use of the data.

Respect Faire's terms, applicable database and copyright rules, privacy laws, and reasonable request volumes.

Do not use the Actor to access private accounts, evade authorization, republish protected creative assets without permission, or make automated purchasing decisions without review.

You are responsible for ensuring that your collection and downstream use are lawful.

### Frequently asked questions

#### Do I need a Faire buyer account?

No. The supported workflow reads public product-detail pages.

#### Can it search Faire for products?

No. V1 requires supplied product URLs and does not claim search or category discovery.

#### Can it process a Faire sitemap?

No. Sitemap input is deliberately outside this version's contract.

#### Does it extract wholesale buyer prices?

It extracts public retail-price and order-term values only, not private buyer pricing or deals.

#### Does it return every variant?

It reports the option count and flattens the primary active option into the product row.

#### Can I monitor products every day?

Yes. Use an Apify schedule and compare numeric values by `productToken` and `scrapedAt`.

#### Why are monetary values in cents?

Integer cents avoid floating-point errors and preserve the source representation for calculations.

#### What happens if Faire blocks every request?

After bounded proxy-session retries, the run fails rather than returning an empty successful dataset.

### Related ecommerce scrapers

Expand the same catalog workflow with other Automation Lab actors:

- [Amazon Scraper](https://apify.com/automation-lab/amazon-scraper) for retail marketplace search data
- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper) for review intelligence
- [Google Shopping Scraper](https://apify.com/automation-lab/google-shopping-scraper) for cross-retailer product comparisons
- [Shopify App Reviews Scraper](https://apify.com/automation-lab/shopify-app-reviews-scraper) for ecommerce software research

Related actors cover different public sources and do not replace Faire-specific wholesale order fields.

### Support

For a reproducible issue, include the public Faire product URL, run ID, approximate run time, and the relevant log message.

Do not post Apify tokens, proxy credentials, Faire account details, or other secrets.

Field requests should explain the public source value and the sourcing or catalog workflow it supports.

# Actor input Schema

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

Add public Faire product-detail URLs. Search, category, brand, and sitemap URLs are intentionally not accepted in this version.

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

Stop after this many unique supplied Faire products.

## `maxRequestRetries` (type: `integer`):

Rotate the proxy session after a challenge or incomplete page.

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

Use Apify Proxy or your own proxy URLs. Leave unchanged for the recommended SHADER US route.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.faire.com/product/p_8x9adp4dzv"
    }
  ],
  "maxItems": 1,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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.faire.com/product/p_8x9adp4dzv"
        }
    ],
    "maxItems": 1,
    "maxRequestRetries": 3,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "SHADER"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/faire-product-brand-details-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.faire.com/product/p_8x9adp4dzv" }],
    "maxItems": 1,
    "maxRequestRetries": 3,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["SHADER"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/faire-product-brand-details-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.faire.com/product/p_8x9adp4dzv"
    }
  ],
  "maxItems": 1,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call automation-lab/faire-product-brand-details-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Faire Product & Brand Details Scraper",
        "description": "🛍️ Turn supplied public Faire product URLs into sourcing-ready stock, retail-price, MOQ, option, image, orderability, lead-time, rating, review, and brand minimum records.",
        "version": "0.1",
        "x-build-id": "O26qz6UADTcyZefMe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~faire-product-brand-details-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-faire-product-brand-details-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~faire-product-brand-details-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-faire-product-brand-details-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~faire-product-brand-details-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-faire-product-brand-details-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": "Faire product URLs",
                        "type": "array",
                        "description": "Add public Faire product-detail URLs. Search, category, brand, and sitemap URLs are intentionally not accepted in this version.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Stop after this many unique supplied Faire products.",
                        "default": 10
                    },
                    "maxRequestRetries": {
                        "title": "Retries per product",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Rotate the proxy session after a challenge or incomplete page.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use Apify Proxy or your own proxy URLs. Leave unchanged for the recommended SHADER US route.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "SHADER"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```