# 1800PetMeds Scraper (`crawlerbros/1800petmeds-scraper`) Actor

Scrape 1800PetMeds' pet medication and supply catalog. Search by keyword, browse by pet type (dog/cat/horse) and department (food, health & wellness, pharmacy, supplies, treats), or by brand. Filter by price, rating, and prescription requirement. No login, no cookies, no paid proxy.

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

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## 1800PetMeds Scraper

Scrape [1800PetMeds](https://www.1800petmeds.com)'s pet medication and supply catalog — search by keyword, browse by pet type and department, or by brand, with price, rating, and prescription filters. Uses 1800PetMeds' public storefront pages. No login, no cookies, no paid proxy required.

### What this actor does

- **Three modes:** `search`, `byCategory`, `byBrand`
- **3 pet types:** Dog, Cat, Horse
- **5 departments per pet type:** Food, Health & Wellness, Pharmacy (Rx), Supplies, Treats
- **93 precise sub-categories:** e.g. "Dog > Pharmacy (Rx) > Flea & Tick", "Cat > Food > Kitten Food"
- **30+ curated brands** plus free-text override for any other brand
- **Filters:** price range, minimum customer rating, prescription-required only
- **Sort order:** relevance (default), name A-Z/Z-A, price low-to-high, rating high-to-low, newest — matches 1800PetMeds' own sort dropdown
- **Empty fields are omitted**

### Output per product

- `productId` — 1800PetMeds product ID
- `title`
- `brand`
- `manufacturer` — underlying pharmaceutical/pet-food manufacturer, when distinct from `brand`
- `category` — specific therapy/product category (e.g. "Heartworm & Flea Prevention")
- `petType` — dog / cat / horse
- `price`, `currency` (USD)
- `requiresPrescription` — `true` if a veterinary prescription is required
- `rating` — 0-5 customer rating
- `reviewCount`
- `imageUrl`
- `productUrl`
- `recordType: "product"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` / `byBrand` |
| `searchQuery` | string | `flea and tick` | Keyword matched against title + brand (mode=search) |
| `petType` | select | – | dog / cat / horse (mode=byCategory; also a filter in other modes) |
| `categoryGroup` | select | – | Department within `petType` (mode=byCategory) |
| `subCategory` | select | – | Exact leaf category — overrides `petType`+`categoryGroup` (mode=byCategory) |
| `brand` | select | – | Curated top brand (mode=byBrand; exact match) |
| `brandQuery` | string | – | Free-text brand substring — overrides `brand` when set |
| `minPrice` / `maxPrice` | number | – | Price range in USD |
| `minRating` | number | – | Minimum customer rating (0-5) |
| `sortBy` | select | `relevance` | `relevance` / `title-asc` / `title-desc` / `price-asc` / `review-desc` / `newest` |
| `prescriptionOnly` | boolean | `false` | Only emit prescription-required products |
| `maxItems` | int | `20` | Hard cap (1–1000) |
| `proxyConfiguration` | object | AUTO | Optional; only engaged automatically if the site rate-limits/blocks the request |

#### Example: search

```json
{ "mode": "search", "searchQuery": "heartworm", "maxItems": 20 }
````

#### Example: browse a precise sub-category with filters

```json
{
  "mode": "byCategory",
  "subCategory": "dog:pharmacy:flea-and-tick",
  "maxPrice": 60,
  "minRating": 4,
  "maxItems": 30
}
```

#### Example: browse a pet type + department (no exact sub-category)

```json
{ "mode": "byCategory", "petType": "cat", "categoryGroup": "food", "maxItems": 30 }
```

#### Example: browse a brand not in the curated dropdown

```json
{ "mode": "byBrand", "brandQuery": "Greenies", "maxItems": 20 }
```

### Use cases

- **Prescription-medication monitoring** — track pricing and availability of vet-prescribed flea/tick, heartworm, and chronic-condition medications
- **Pet-food market research** — compare pricing and assortment across pet-food brands and diet types (senior, puppy/kitten, veterinary diet)
- **Price comparison** — build a pricing feed for competitor benchmarking in the pet pharmacy space
- **Product data enrichment** — bulk-fetch structured product data (rating, review count, prescription flag) for a category
- **Content/catalog audits** — verify the breadth of prescription vs. over-the-counter offerings per pet type

### FAQ

**Does this require login or cookies?** No. 1800PetMeds' public product catalog pages are fully accessible without authentication.

**How is `requiresPrescription` determined?** From the product's own category classification (`rx` vs `otc`) combined with the presence of the site's own "Rx" badge on the product tile — both signals agree in all sampled cases.

**What's the difference between `brand` and `manufacturer`?** `brand` is the consumer-facing product line (e.g. "Simparica TRIO"); `manufacturer` is the underlying pharmaceutical or pet-food company (e.g. "ZOETIS"). Both are included when they differ.

**Can I search for a brand that isn't in the dropdown?** Yes — use `brandQuery` for a free-text substring match.

**What currency are prices in?** US dollars (USD) — 1800PetMeds is a US retailer.

**Why 93 sub-categories instead of a simpler taxonomy?** 1800PetMeds' own navigation is genuinely this granular (e.g. "Heart & Blood Pressure" and "Seizure Disorder" are separate prescription categories for dogs). Exposing the full taxonomy as a dropdown avoids silent 0-result runs from guessed category slugs.

**How fresh is the data?** Real-time — every run queries 1800PetMeds' live storefront pages directly.

**Can I fetch a single product by its URL or product ID?** Not as a dedicated mode. `search`/`byCategory`/`byBrand` all scrape the grid/tile view (title, brand, price, rating, image, etc.) — a single-product deep-fetch mode would need a separate detail-page parser (full description, directions, ingredients/active-ingredient tables, warnings) not currently implemented. Considered out of scope for this version; the tile-level fields cover the common price/catalog-monitoring use cases.

# Actor input Schema

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

What to fetch.

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

Free-text keyword matched against product title and brand (mode=search).

## `petType` (type: `string`):

Browse a specific pet type (mode=byCategory; also usable as a filter in other modes).

## `categoryGroup` (type: `string`):

Department within the chosen pet type (mode=byCategory). Requires `petType`.

## `subCategory` (type: `string`):

Pick an exact leaf category (e.g. "Dog > Pharmacy (Rx) > Flea & Tick"). Overrides `petType` + `categoryGroup` when set (mode=byCategory).

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

Curated top brand to browse/filter by exact match (mode=byBrand). For any other brand use `brandQuery` instead.

## `brandQuery` (type: `string`):

Free-text substring match on brand — overrides `brand` when set. Use for any brand not in the curated dropdown.

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

Drop products cheaper than this.

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

Drop products more expensive than this.

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

Drop products rated below this (0-5 stars). Products with no rating yet are excluded when this is set.

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

Result order, matching 1800PetMeds' own sort dropdown. Applies to all modes.

## `prescriptionOnly` (type: `boolean`):

Only emit products that require a vet prescription.

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

Hard cap on emitted records.

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

Optional. Only used as an automatic fallback if 1800PetMeds rate-limits (429) or blocks (403) the default datacenter IP. Uses the free AUTO group.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "flea and tick",
  "petType": "",
  "categoryGroup": "",
  "subCategory": "",
  "brand": "",
  "sortBy": "relevance",
  "prescriptionOnly": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped 1800PetMeds products.

# 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",
    "searchQuery": "flea and tick",
    "petType": "",
    "categoryGroup": "",
    "subCategory": "",
    "brand": "",
    "sortBy": "relevance",
    "prescriptionOnly": false,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/1800petmeds-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",
    "searchQuery": "flea and tick",
    "petType": "",
    "categoryGroup": "",
    "subCategory": "",
    "brand": "",
    "sortBy": "relevance",
    "prescriptionOnly": False,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/1800petmeds-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",
  "searchQuery": "flea and tick",
  "petType": "",
  "categoryGroup": "",
  "subCategory": "",
  "brand": "",
  "sortBy": "relevance",
  "prescriptionOnly": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/1800petmeds-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "1800PetMeds Scraper",
        "description": "Scrape 1800PetMeds' pet medication and supply catalog. Search by keyword, browse by pet type (dog/cat/horse) and department (food, health & wellness, pharmacy, supplies, treats), or by brand. Filter by price, rating, and prescription requirement. No login, no cookies, no paid proxy.",
        "version": "1.0",
        "x-build-id": "VvLtBg0psyZs7VuIQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~1800petmeds-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-1800petmeds-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~1800petmeds-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-1800petmeds-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~1800petmeds-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-1800petmeds-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"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text keyword matched against product title and brand (mode=search).",
                        "default": "flea and tick"
                    },
                    "petType": {
                        "title": "Pet type",
                        "enum": [
                            "",
                            "dog",
                            "cat",
                            "horse"
                        ],
                        "type": "string",
                        "description": "Browse a specific pet type (mode=byCategory; also usable as a filter in other modes).",
                        "default": ""
                    },
                    "categoryGroup": {
                        "title": "Category group",
                        "enum": [
                            "",
                            "food",
                            "health-and-wellness",
                            "pharmacy",
                            "supplies",
                            "treats"
                        ],
                        "type": "string",
                        "description": "Department within the chosen pet type (mode=byCategory). Requires `petType`.",
                        "default": ""
                    },
                    "subCategory": {
                        "title": "Sub-category (precise leaf category)",
                        "enum": [
                            "",
                            "cat:food:dry-food",
                            "cat:food:kitten-food",
                            "cat:food:premium-food",
                            "cat:food:raw-freeze-dried-and-dehydrated-food",
                            "cat:food:senior-cat-food",
                            "cat:food:veterinary-diet",
                            "cat:food:wet-food",
                            "cat:health-and-wellness:calming-and-anxiety",
                            "cat:health-and-wellness:dewormers",
                            "cat:health-and-wellness:digestive-health",
                            "cat:health-and-wellness:flea-and-tick",
                            "cat:health-and-wellness:heart-and-liver",
                            "cat:health-and-wellness:hip-and-joint",
                            "cat:health-and-wellness:skin-and-coat",
                            "cat:health-and-wellness:urinary-and-kidney",
                            "cat:health-and-wellness:vitamins-and-supplements",
                            "cat:pharmacy:dewormer",
                            "cat:pharmacy:digestive-care",
                            "cat:pharmacy:flea-and-tick",
                            "cat:pharmacy:heartworm-medicine",
                            "cat:pharmacy:hormonal-and-endocrine",
                            "cat:pharmacy:prescription-food",
                            "cat:pharmacy:prescription-treats",
                            "cat:pharmacy:skin-care",
                            "cat:pharmacy:urinary-tract-and-kidneys",
                            "cat:supplies:beauty-and-grooming",
                            "cat:supplies:cleaners-and-stain-removers",
                            "cat:supplies:litter-and-accessories",
                            "cat:supplies:test-kits",
                            "cat:supplies:toys-play-and-enrichment",
                            "cat:supplies:training-and-behavior",
                            "cat:treats:biscuits-and-crunchy-treats",
                            "cat:treats:dental-treats",
                            "cat:treats:pill-pockets",
                            "cat:treats:prescription-treats",
                            "cat:treats:soft-and-chewy-treats",
                            "dog:food:dry-food",
                            "dog:food:premium-food",
                            "dog:food:puppy-food",
                            "dog:food:raw-freeze-dried-and-dehydrated-food",
                            "dog:food:senior-dog-food",
                            "dog:food:toppers",
                            "dog:food:veterinary-diet",
                            "dog:food:wet-food",
                            "dog:health-and-wellness:antibiotics-and-anti-infectives",
                            "dog:health-and-wellness:calming-and-anxiety",
                            "dog:health-and-wellness:dental",
                            "dog:health-and-wellness:flea-and-tick",
                            "dog:health-and-wellness:heart-and-liver",
                            "dog:health-and-wellness:hip-and-joint",
                            "dog:health-and-wellness:skin-and-coat",
                            "dog:health-and-wellness:urinary-and-kidney",
                            "dog:health-and-wellness:vitamins-and-supplements",
                            "dog:pharmacy:anxiety-relief",
                            "dog:pharmacy:flea-and-tick",
                            "dog:pharmacy:heart-and-blood-pressure",
                            "dog:pharmacy:heartworm-medicine",
                            "dog:pharmacy:hormonal-and-endocrine",
                            "dog:pharmacy:pain-and-inflammation-relief",
                            "dog:pharmacy:seizure-disorder",
                            "dog:pharmacy:skin-care",
                            "dog:pharmacy:urinary-tract-and-kidneys",
                            "dog:supplies:beauty-and-grooming",
                            "dog:supplies:beds-crates-and-gear",
                            "dog:supplies:bowls-and-feeding",
                            "dog:supplies:cleaners-and-stain-removers",
                            "dog:supplies:test-kits",
                            "dog:supplies:toys",
                            "dog:supplies:training-and-behavior",
                            "dog:supplies:waste-management",
                            "dog:treats:biscuits-and-crunchy-treats",
                            "dog:treats:bones-and-antlers",
                            "dog:treats:bully-sticks",
                            "dog:treats:dental-and-hard-chews",
                            "dog:treats:pill-pockets",
                            "dog:treats:prescription-treats",
                            "dog:treats:soft-and-chewy-treats",
                            "horse:health-and-wellness:beauty-and-grooming",
                            "horse:health-and-wellness:calming-and-anxiety",
                            "horse:health-and-wellness:dewormers",
                            "horse:health-and-wellness:digestive-health",
                            "horse:health-and-wellness:first-aid",
                            "horse:health-and-wellness:hip-and-joint",
                            "horse:health-and-wellness:hoof-care",
                            "horse:health-and-wellness:shampoos-and-conditioners",
                            "horse:health-and-wellness:vitamins-and-supplements",
                            "horse:pharmacy:antibiotics",
                            "horse:pharmacy:digestive-care",
                            "horse:pharmacy:diuretics",
                            "horse:pharmacy:eye-care",
                            "horse:pharmacy:hormonal-and-endocrine",
                            "horse:pharmacy:joint-care",
                            "horse:pharmacy:pain"
                        ],
                        "type": "string",
                        "description": "Pick an exact leaf category (e.g. \"Dog > Pharmacy (Rx) > Flea & Tick\"). Overrides `petType` + `categoryGroup` when set (mode=byCategory).",
                        "default": ""
                    },
                    "brand": {
                        "title": "Brand",
                        "enum": [
                            "",
                            "Hill's Science Diet",
                            "Simparica TRIO",
                            "NexGard",
                            "NexGard Plus",
                            "Trifexis",
                            "Credelio",
                            "Credelio Quattro",
                            "Revolution",
                            "Revolution Plus",
                            "Bravecto",
                            "Sentinel",
                            "Sentinel Spectrum",
                            "Seresto",
                            "Comfortis",
                            "Interceptor",
                            "Zesty Paws",
                            "Royal Canin",
                            "Purina Pro Plan",
                            "Purina ONE",
                            "Blue Buffalo",
                            "Taste of the Wild",
                            "Orijen",
                            "Nulo",
                            "Iams",
                            "Diamond",
                            "Farmina",
                            "TropiClean",
                            "NaturVet",
                            "Apoquel",
                            "Oravet",
                            "Rimadyl",
                            "Zenrelia",
                            "Simparica",
                            "Alzoo"
                        ],
                        "type": "string",
                        "description": "Curated top brand to browse/filter by exact match (mode=byBrand). For any other brand use `brandQuery` instead.",
                        "default": ""
                    },
                    "brandQuery": {
                        "title": "Brand (free text)",
                        "type": "string",
                        "description": "Free-text substring match on brand — overrides `brand` when set. Use for any brand not in the curated dropdown."
                    },
                    "minPrice": {
                        "title": "Min price (USD)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "number",
                        "description": "Drop products cheaper than this."
                    },
                    "maxPrice": {
                        "title": "Max price (USD)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "number",
                        "description": "Drop products more expensive than this."
                    },
                    "minRating": {
                        "title": "Min customer rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Drop products rated below this (0-5 stars). Products with no rating yet are excluded when this is set."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "title-asc",
                            "title-desc",
                            "price-asc",
                            "review-desc",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Result order, matching 1800PetMeds' own sort dropdown. Applies to all modes.",
                        "default": "relevance"
                    },
                    "prescriptionOnly": {
                        "title": "Prescription items only",
                        "type": "boolean",
                        "description": "Only emit products that require a vet prescription.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Only used as an automatic fallback if 1800PetMeds rate-limits (429) or blocks (403) the default datacenter IP. Uses the free AUTO group.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
