# GoodBuy Gear Scraper - Baby & Kids Gear Resale (`crawlerbros/goodbuygear-scraper`) Actor

Scrape GoodBuy Gear, the largest certified-resale marketplace for baby and kids gear. Search by keyword, browse 500+ categories (strollers, car seats, cribs, maternity/nursing, toys), or filter by brand. Get price, brand, condition, age group, seller, and images.

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

## GoodBuy Gear Scraper - Baby & Kids Gear Resale Marketplace

Scrape **GoodBuy Gear** (goodbuygear.com) — the largest certified-resale marketplace for baby and kids gear in the US. Search any keyword, browse 45+ curated categories (strollers, car seats, cribs, nursing/maternity, toys, and more), or pull every listing from a single brand. Get price, brand, condition, age group, seller, and product images for every item. No login, no cookies, no API key required.

### What this actor does

- **Four modes:** `search` (free-text keyword), `byCategory` (browse a category), `byBrand` (all listings from one brand), and `listCategories` (enumerate every live category with its product count, to discover slugs)
- **45+ curated categories** to pick from, or type any GoodBuy Gear category slug directly
- **2,600+ brands** supported via free-text brand matching (Nuna, UPPAbaby, Graco, Cybex, Doona, 4moms, and thousands more)
- **Filter by** condition (Brand New / Unopened & Overstock / Barely Used / Gently Used / Loved / Open Box), age group (0-3 months through Grown-up), price range, and in-stock status
- **Sort by** relevance, price (low-to-high or high-to-low), or newest first
- **Real seller/consignor identity** on every listing, plus every product photo
- **Empty fields are omitted** — you only ever see fields that were actually populated for a listing

### Output per category (mode=listCategories)

- `title` — category name (e.g. `"Convertible Car Seats"`)
- `handle` — the GoodBuy Gear category slug, usable directly as `category`/`customCategory` in `byCategory` mode
- `description` — the category's own description text, when GoodBuy Gear has one
- `productsCount` — live count of products currently in that category
- `imageUrl` — the category's banner/thumbnail image, when set
- `sourceUrl` — canonical `goodbuygear.com/collections/<handle>` page
- `publishedAt`, `updatedAt` — category timestamps
- `recordType: "category"`, `scrapedAt`

### Output per product

- `title` — product listing title
- `description` — the seller's product description (condition notes and "buy new" promo links are stripped out separately)
- `brand` — brand name (e.g. `"Nuna"`, `"4moms"`, `"UPPAbaby"`)
- `condition` — one of `Brand New`, `Unopened & Overstock`, `Barely Used`, `Gently Used`, `Loved`, `Open Box`
- `ageGroups` — age range(s) the item is tagged for (e.g. `["0-3 months", "3-12 months"]`)
- `color`, `model`, `modelYear` — when the seller specified them (`modelYear` is the product's model year, e.g. `2026`)
- `frameColor`, `canopyColor`, `fabricColor` — separate color call-outs strollers and travel systems often use in place of (or alongside) a single `color`
- `category` — product category (e.g. `"Infant Gear"`, `"Home Nursery"`)
- `specs` — a free-form object of other category-specific attributes GoodBuy Gear tags per listing (e.g. `{"Terrain": "Smooth", "Seat Recline": "yes", "Base Included?": "Yes"}` on a stroller/car seat, `{"Flange Size": "24mm"}` on a breast pump) — keys vary by product category since GoodBuy Gear doesn't use a fixed attribute set across its whole catalog
- `sellerName` — the consignor/seller account the item was listed under
- `price`, `compareAtPrice`, `discountPercent`, `currency` — always USD
- `inStock` — whether the item is still available for purchase
- `sku`, `weightGrams` — shipping weight in grams, when GoodBuy Gear records one
- `packageDimensions` — shipping box dimensions in inches, e.g. `"38x28x18"` (L x W x H), when available
- `images[]`, `primaryImage` — all product photos, and the first one
- `publishedAt`, `createdAt`, `updatedAt` — listing timestamps
- `searchQuery` / `searchCategory` / `searchBrand` — the search parameters used, echoed back for traceability
- `sourceUrl` — canonical goodbuygear.com product page
- `recordType: "product"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string (select) | `search` | `search` (keyword), `byCategory` (browse), `byBrand` (all items from one brand), or `listCategories` (enumerate all categories) |
| `query` | string | `stroller` | Keyword to search for (mode=search); matched against title, brand, model, and category |
| `category` | string (select) | `strollers` | Pick a common category, or `custom` to use `customCategory` (mode=byCategory) |
| `customCategory` | string | – | Any GoodBuy Gear category slug not in the curated list, overrides `category` (mode=byCategory) |
| `brand` | string | `4moms` | Exact brand name to browse (mode=byBrand) |
| `condition` | string (select) | – (any) | Only return items in this condition |
| `ageGroup` | string (select) | – (any) | Only return items tagged for this age group |
| `minPrice` / `maxPrice` | integer | `0` (no bound) | Price range in USD |
| `inStockOnly` | boolean | `false` | Only return items currently available for purchase |
| `sortBy` | string (select) | `relevance` | `relevance`, `priceLowToHigh`, `priceHighToLow`, or `newest` — applied client-side across the fetched batch |
| `maxItems` | int | `30` | Hard cap on returned records (1-5000) |

#### Example: search for strollers under $200

```json
{
  "mode": "search",
  "query": "stroller",
  "maxPrice": 200,
  "maxItems": 30
}
````

#### Example: browse convertible car seats, gently used, in stock only

```json
{
  "mode": "byCategory",
  "category": "convertible-car-seats",
  "condition": "Gently Used",
  "inStockOnly": true,
  "maxItems": 50
}
```

#### Example: everything from a specific brand, cheapest first

```json
{
  "mode": "byBrand",
  "brand": "UPPAbaby",
  "sortBy": "priceLowToHigh",
  "maxItems": 100
}
```

#### Example: nursing/maternity items for a newborn

```json
{
  "mode": "byCategory",
  "category": "nursing-maternity",
  "ageGroup": "0-3 months",
  "maxItems": 40
}
```

#### Example: discover every category slug and its live product count

```json
{
  "mode": "listCategories",
  "maxItems": 1000
}
```

### Use cases

- **Deal hunting** — track price drops on specific strollers, car seats, or cribs across the whole marketplace
- **Resale market research** — measure how brands and conditions affect resale pricing for baby gear
- **Inventory monitoring** — watch a favorite brand's listings for new arrivals or restocks
- **Price comparison** — compare `price` against `compareAtPrice`/`discountPercent` to find the best certified-resale deals
- **Sustainability/circular-economy analysis** — study the secondhand baby gear market at scale

### Limitations

- **GoodBuy Gear specializes in gear, furniture, and maternity/nursing items — not apparel.** Its catalog (25,000+ live listings across 595 categories, confirmed via the storefront's own metadata) covers strollers, car seats, cribs, feeding, diapering, toys, and nursing/maternity supplies. It does not carry kids' clothing.
- **`brand` is free text, not a dropdown.** GoodBuy Gear partners with 2,600+ brands, far more than a stable curated list can cover reliably — use the exact `brand` value from a `search` or `byCategory` result for a guaranteed match on `byBrand`.
- **Sorting is applied client-side**, across the batch of records this run actually fetched, since the underlying catalog endpoint returns items in a fixed order rather than honoring a sort parameter.
- **Keyword search matches title, brand, model, category, and description** — a small share of listings have no seller-written description, so a very specific phrase found only in a missing description may return fewer results than browsing the matching category directly.
- **A `search` keyword with no matches anywhere in the catalog takes several minutes to confirm 0 results**, since the actor pages through the entire ~25,000-item catalog before giving up (rather than guessing a smaller scan limit and risking a false "no results"). Matching keywords typically return results within seconds. `byCategory` and `byBrand` runs are unaffected since they're scoped to a much smaller product set from the start.
- **GoodBuy Gear ships to the US and Canada only** — this is a single-market (US-priced, USD) marketplace, so no country/locale input is offered.

### Data source

This actor reads GoodBuy Gear's own public storefront JSON endpoints (the same data used to render the site itself), which are served with no login, no cookies, and no anti-bot challenge. It runs entirely on Apify's free plan with no proxy and no credentials required.

**Why GoodBuy Gear and not Kidizen?** This actor was originally scoped for Kidizen, a former kids/maternity clothing resale marketplace. At the time of building, `kidizen.com` was confirmed to be a **parked/expired domain** (it now serves a GoDaddy domain-parking page, not the marketplace) — there is no live Kidizen service left to scrape. A same-category clothing alternative (ThredUp's kids section) was also evaluated, but its product-search API requires an authenticated session that returns errors for unauthenticated requests, and its category pages are additionally protected by Cloudflare bot management that blocks automated browsers — neither is reliably scrapable without paid residential proxies or user-supplied login credentials, which this project's zero-cost policy rules out. GoodBuy Gear was selected as a same-broad-category (kids/baby resale) replacement because it exposes a fully public, well-documented Shopify storefront API with no anti-bot friction of any kind.

### FAQ

**What data source does this actor use?**
It reads the publicly available product-catalog JSON endpoints on goodbuygear.com. No account or API key is needed.

**Is this affiliated with GoodBuy Gear?**
No. This is an independent, third-party actor that reads publicly accessible data.

**Why do some listings have no `compareAtPrice` or `discountPercent`?**
Those fields are only included when GoodBuy Gear lists an original/compare price higher than the current resale price. Items without a discount simply omit these fields rather than showing them as zero or null.

**Why is `brand` sometimes missing?**
A small share of listings aren't tagged with a brand by the seller. `sellerName`, `condition`, and `ageGroups` follow the same rule — only included when GoodBuy Gear actually has the data.

**Why does `specs` have different keys on different products?**
GoodBuy Gear tags category-specific attributes per listing rather than using one fixed attribute set for the whole catalog — a stroller might carry `Terrain` and `Seat Recline`, a breast pump might carry `Flange Size`, and a car seat might carry `Base Included?`. `specs` passes through whatever attributes GoodBuy Gear actually recorded for that listing; internal warehousing/logistics tags (shipping-zone codes, image-ingest flags) are filtered out since they aren't buyer-facing product attributes.

**Does this actor need a proxy or login?**
No — GoodBuy Gear's product catalog is served without any anti-bot challenge, so this actor runs entirely on Apify's free plan with no proxy and no credentials.

**How do I find a category slug for `customCategory`?**
Run this actor with `mode: "listCategories"` — it returns every live GoodBuy Gear category with its `handle` (the slug), current `productsCount`, and description, so you can pick an exact match instead of guessing.

**Can I get every listing for a whole category?**
Yes — set `mode` to `byCategory` and raise `maxItems` up to 5000; the actor paginates the category's full catalog until either `maxItems` is reached or the category is exhausted.

# Actor input Schema

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

What to fetch: free-text keyword search across the whole catalog, browse a single category, fetch all listings from one brand, or list every category GoodBuy Gear has (with its live product count) to discover slugs for 'Custom category'.

## `query` (type: `string`):

Free-text keyword to search for, e.g. 'stroller', 'car seat', 'Nuna crib' (mode=search). Matched against product title, brand, model, and category.

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

Category to browse (mode=byCategory). Pick a common category, or choose 'Custom category' and type the exact GoodBuy Gear category slug below.

## `customCategory` (type: `string`):

Exact GoodBuy Gear category slug not in the curated list above, e.g. 'cybex-strollers' or 'bumbleride' (mode=byCategory). Find slugs in any goodbuygear.com/collections/<slug> URL. Takes priority over 'Category' when set.

## `brand` (type: `string`):

Exact brand name to browse, e.g. '4moms', 'UPPAbaby', 'Nuna', 'Graco', 'Cybex', 'Doona' (mode=byBrand). GoodBuy Gear carries 2,600+ brands so this is free text rather than a dropdown -- use the 'brand' field from search results for an exact match.

## `condition` (type: `string`):

Only return items in this condition. Leave as 'Any condition' to include all.

## `ageGroup` (type: `string`):

Only return items tagged for this age group. Leave as 'Any age group' to include all.

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

Only return items priced at or above this amount, in US dollars. 0 means no minimum.

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

Only return items priced at or below this amount, in US dollars. 0 means no maximum.

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

Only return items currently available for purchase (excludes sold-out listings).

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

How to order results after fetching. GoodBuy Gear itself returns catalog order, so all options here are applied client-side across the fetched batch.

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

Hard cap on the number of records to return (products for search/byCategory/byBrand, categories for listCategories).

## Actor input object example

```json
{
  "mode": "search",
  "query": "stroller",
  "category": "strollers",
  "brand": "4moms",
  "condition": "",
  "ageGroup": "",
  "minPrice": 0,
  "maxPrice": 0,
  "inStockOnly": false,
  "sortBy": "relevance",
  "maxItems": 30
}
```

# Actor output Schema

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

Dataset containing all scraped GoodBuy Gear product listings.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "search",
    "query": "stroller",
    "category": "strollers",
    "brand": "4moms",
    "condition": "",
    "ageGroup": "",
    "minPrice": 0,
    "maxPrice": 0,
    "inStockOnly": false,
    "sortBy": "relevance",
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/goodbuygear-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "search",
    "query": "stroller",
    "category": "strollers",
    "brand": "4moms",
    "condition": "",
    "ageGroup": "",
    "minPrice": 0,
    "maxPrice": 0,
    "inStockOnly": False,
    "sortBy": "relevance",
    "maxItems": 30,
}

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

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

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

```

## CLI example

```bash
echo '{
  "mode": "search",
  "query": "stroller",
  "category": "strollers",
  "brand": "4moms",
  "condition": "",
  "ageGroup": "",
  "minPrice": 0,
  "maxPrice": 0,
  "inStockOnly": false,
  "sortBy": "relevance",
  "maxItems": 30
}' |
apify call crawlerbros/goodbuygear-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GoodBuy Gear Scraper - Baby & Kids Gear Resale",
        "description": "Scrape GoodBuy Gear, the largest certified-resale marketplace for baby and kids gear. Search by keyword, browse 500+ categories (strollers, car seats, cribs, maternity/nursing, toys), or filter by brand. Get price, brand, condition, age group, seller, and images.",
        "version": "1.0",
        "x-build-id": "ImxgbwjVDCZhp0U71"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~goodbuygear-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-goodbuygear-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~goodbuygear-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-goodbuygear-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~goodbuygear-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-goodbuygear-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCategory",
                            "byBrand",
                            "listCategories"
                        ],
                        "type": "string",
                        "description": "What to fetch: free-text keyword search across the whole catalog, browse a single category, fetch all listings from one brand, or list every category GoodBuy Gear has (with its live product count) to discover slugs for 'Custom category'.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Free-text keyword to search for, e.g. 'stroller', 'car seat', 'Nuna crib' (mode=search). Matched against product title, brand, model, and category.",
                        "default": "stroller"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "custom",
                            "strollers",
                            "convertible-strollers",
                            "double-strollers",
                            "compact-strollers-shipping-cost-included",
                            "jogging-stroller",
                            "car-seats",
                            "infant-car-seats",
                            "convertible-car-seats",
                            "booster-car-seats",
                            "all-in-one-car-seats",
                            "combination-car-seats",
                            "car-seat-travel-systems",
                            "car-seat-accessories",
                            "cribs",
                            "cribs-sleepers",
                            "furniture",
                            "change-tables",
                            "change-pads",
                            "carrier",
                            "activity-centers",
                            "bouncers",
                            "swings",
                            "jumpers",
                            "walkers",
                            "gym-playmats",
                            "floor-seats",
                            "high-chairs",
                            "feeding",
                            "bathing",
                            "bedding-swaddles",
                            "monitors-electronics",
                            "electronics",
                            "diapering",
                            "diaper-bags",
                            "cloth-diapers",
                            "potty-training",
                            "nursing-maternity",
                            "safety",
                            "infant-toddler-toys",
                            "dolls-princesses",
                            "crafts-games",
                            "art-music",
                            "active-play",
                            "backpacks",
                            "bicycle-child-seats-trailers",
                            "booster-seats",
                            "infant-gear",
                            "appliances"
                        ],
                        "type": "string",
                        "description": "Category to browse (mode=byCategory). Pick a common category, or choose 'Custom category' and type the exact GoodBuy Gear category slug below.",
                        "default": "strollers"
                    },
                    "customCategory": {
                        "title": "Custom category slug (overrides selection above)",
                        "type": "string",
                        "description": "Exact GoodBuy Gear category slug not in the curated list above, e.g. 'cybex-strollers' or 'bumbleride' (mode=byCategory). Find slugs in any goodbuygear.com/collections/<slug> URL. Takes priority over 'Category' when set."
                    },
                    "brand": {
                        "title": "Brand",
                        "type": "string",
                        "description": "Exact brand name to browse, e.g. '4moms', 'UPPAbaby', 'Nuna', 'Graco', 'Cybex', 'Doona' (mode=byBrand). GoodBuy Gear carries 2,600+ brands so this is free text rather than a dropdown -- use the 'brand' field from search results for an exact match.",
                        "default": "4moms"
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "",
                            "Brand New",
                            "Unopened & Overstock",
                            "Barely Used",
                            "Gently Used",
                            "Loved",
                            "Open Box"
                        ],
                        "type": "string",
                        "description": "Only return items in this condition. Leave as 'Any condition' to include all.",
                        "default": ""
                    },
                    "ageGroup": {
                        "title": "Age group",
                        "enum": [
                            "",
                            "0-3 months",
                            "3-12 months",
                            "Toddler",
                            "Preschool",
                            "Gradeschool",
                            "10+ years",
                            "Grown-up"
                        ],
                        "type": "string",
                        "description": "Only return items tagged for this age group. Leave as 'Any age group' to include all.",
                        "default": ""
                    },
                    "minPrice": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Only return items priced at or above this amount, in US dollars. 0 means no minimum.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Only return items priced at or below this amount, in US dollars. 0 means no maximum.",
                        "default": 0
                    },
                    "inStockOnly": {
                        "title": "In stock only",
                        "type": "boolean",
                        "description": "Only return items currently available for purchase (excludes sold-out listings).",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "priceLowToHigh",
                            "priceHighToLow",
                            "newest"
                        ],
                        "type": "string",
                        "description": "How to order results after fetching. GoodBuy Gear itself returns catalog order, so all options here are applied client-side across the fetched batch.",
                        "default": "relevance"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on the number of records to return (products for search/byCategory/byBrand, categories for listCategories).",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
