# Cashify Refurbished Products Scraper (`automation-lab/cashify-refurbished-products-scraper`) Actor

📱 Extract public Cashify India refurbished-device prices, MRP, discounts, ratings, stock, warranty, membership prices, images, and product URLs.

- **URL**: https://apify.com/automation-lab/cashify-refurbished-products-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

from $0.27 / 1,000 cashify product extracteds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## Cashify Refurbished Products Scraper

Extract structured refurbished-device catalog data from public Cashify India category pages.
Get current INR prices, MRP, discount, membership price, ratings, inventory signals, warranty labels, images, and product links in one export-ready dataset.

Use this Cashify scraper for recurring price monitoring, reseller sourcing, catalog comparison, assortment research, or competitive intelligence.
It uses an HTTP-first workflow, so normal runs are fast and do not launch a browser.

- 📱 One row per unique refurbished product
- 💰 Numeric price and discount fields ready for analysis
- 📦 Inventory and availability signals when Cashify exposes them
- 🔗 Direct product and image URLs
- 🔁 Optional linked-brand collection discovery
- 📤 CSV, JSON, Excel, XML, RSS, and API exports through Apify

### What does Cashify Refurbished Products Scraper do?

The Actor visits public Cashify refurbished-mobile category or collection pages and extracts the structured product catalog embedded in each page.
It normalizes every discovered product into a stable dataset record.

A record can contain:

- Cashify product, catalogue, discovery, and variant identifiers
- product title and type
- current price and crossed-out MRP in INR
- discount amount and percentage
- Cashify membership, effective, and channel prices
- monthly EMI amount
- rating and rating count
- inventory count and normalized availability
- sale badge, tags, warranty, and assurance label
- product URL, source collection URL, and image URL
- scrape timestamp

Products repeated across multiple collections are deduplicated by Cashify product ID.

### Who is it for?

#### Indian used-device resellers

Track acquisition and market prices across Cashify's refurbished assortment.
Compare brands, find meaningful discounts, and feed shortlisted products into sourcing workflows.

#### Price-comparison and catalog teams

Create a normalized product feed for dashboards, spreadsheets, internal search, or product matching.
Numeric INR values avoid extra currency-cleaning steps.

#### Refurbishers and distributors

Observe assortment, stock signals, warranty labels, and price movement on recurring schedules.
Use snapshots to support supply and pricing decisions.

#### Market analysts

Measure brand mix, discount depth, rating distribution, and changes in available inventory.
Combine scheduled datasets with BI tools for historical analysis.

#### Developers and data engineers

Call the Actor from Node.js, Python, cURL, webhooks, or MCP.
Integrate the output with databases and downstream enrichment pipelines.

### Why use this Cashify catalog extractor?

Cashify pages are designed for shoppers, not bulk analysis.
Copying cards manually is slow, inconsistent, and difficult to repeat.
This Actor turns public catalog pages into structured records with predictable fields.

Benefits include:

- ⚡ HTTP-first extraction without browser startup overhead
- 🧱 structured embedded-state parsing instead of fragile visual text matching
- 🎯 strict validation of supported Cashify collection URLs
- 🛡️ bounded collection discovery and conservative requests
- ♻️ product-ID deduplication across overlapping brand pages
- ❌ non-zero failure when Cashify returns no extractable products
- 🕒 ISO timestamps for every snapshot

### What Cashify data can I extract?

| Field | Description | Example |
|---|---|---|
| `productId` | Full Cashify catalog identifier | `prod-estore-refurbished-catalogue\|6711` |
| `catalogueId` | Compact catalog ID | `6711` |
| `title` | Refurbished product name | `Apple iPhone 11 - Refurbished` |
| `currentPriceInr` | Current sale price | `15899` |
| `mrpInr` | Crossed-out MRP | `39499` |
| `discountAmountInr` | MRP minus current price | `23600` |
| `discountPercent` | Calculated whole-number discount | `60` |
| `membershipPriceInr` | Cashify membership price | `14993` |
| `emiAmountInr` | Displayed monthly EMI | `795` |
| `rating` | Average customer rating | `4.5` |
| `ratingCount` | Number of ratings | `4603` |
| `inventory` | Inventory signal exposed by Cashify | `21` |
| `available` | Normalized inventory availability | `true` |
| `warranty` | Warranty labels | `["Cashify Warranty"]` |
| `productUrl` | Absolute product URL | Cashify product page |
| `imageUrl` | Absolute image URL | Cashify CDN image |
| `scrapedAt` | UTC extraction time | ISO 8601 timestamp |

Optional fields are omitted when the source does not expose them.

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

The Actor uses pay-per-event pricing:

- a small run-start fee
- one product event for each unique dataset row

The exact active price is displayed in the Apify Console before every run.
Tier discounts may reduce the per-product price on higher Apify plans.
You pay for delivered unique product records, while `maxItems` and `maxCollectionPages` keep spending bounded.

For a cheap first test, use the prefilled input: one collection page and at most 10 products.
Always consult the live pricing panel for the authoritative total.

### How to scrape Cashify refurbished products

1. Open the Actor input page.
2. Keep the prefilled lowest-price collection or add another supported Cashify refurbished category URL.
3. Set **Maximum products** to the number of unique rows you need.
4. Choose whether to follow linked brand collections.
5. Bound the number of requested collection pages.
6. Click **Start**.
7. Review the dataset table.
8. Export to JSON, CSV, Excel, XML, or another supported format.
9. Save the run as a task if you want recurring snapshots.

### Input parameters

#### `startUrls`

An array of public Cashify URLs under:

`https://www.cashify.in/buy-refurbished-mobile-phones/`

Use category or collection pages, not individual `renewed-*` product detail URLs.
Non-Cashify hosts and unrelated paths are rejected.
If omitted through the API, the Actor uses the lowest-price collection.

#### `maxItems`

Global maximum number of unique products to save.
Allowed range: 1 to 10,000.
A small number is best for a smoke test.

#### `followLinkedCollections`

When enabled, the Actor discovers public brand/category links visible on collection pages.
This can broaden coverage beyond the first collection while still respecting `maxCollectionPages`.

#### `maxCollectionPages`

Maximum number of category or collection pages requested during one run.
Allowed range: 1 to 50.
Use a low value for focused monitoring and a higher value for broader snapshots.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.cashify.in/buy-refurbished-mobile-phones/lowest-prices" }
  ],
  "maxItems": 20,
  "followLinkedCollections": true,
  "maxCollectionPages": 3
}
````

For an Apple-only snapshot:

```json
{
  "startUrls": [
    { "url": "https://www.cashify.in/buy-refurbished-mobile-phones/apple" }
  ],
  "maxItems": 10,
  "followLinkedCollections": false,
  "maxCollectionPages": 1
}
```

### Example output

```json
{
  "productId": "prod-estore-refurbished-catalogue|6711",
  "catalogueId": "6711",
  "productDiscoveryId": 22923,
  "variantId": 107966,
  "title": "Apple iPhone 11 - Refurbished",
  "productType": "Mobile Phone",
  "productUrl": "https://www.cashify.in/buy-refurbished-mobile-phones/renewed-apple-iphone-11",
  "sourceUrl": "https://www.cashify.in/buy-refurbished-mobile-phones/lowest-prices",
  "currentPriceInr": 15899,
  "mrpInr": 39499,
  "discountAmountInr": 23600,
  "discountPercent": 60,
  "membershipPriceInr": 14993,
  "rating": 4.5,
  "ratingCount": 4603,
  "inventory": 21,
  "available": true,
  "warranty": ["Cashify Warranty"],
  "scrapedAt": "2026-07-24T00:00:00.000Z"
}
```

Values change on the live source, so this example illustrates shape rather than a guaranteed offer.

### Tips for reliable Cashify monitoring

- 🧪 Start with 10 products and one collection page.
- 🎯 Disable linked collections when you only need one brand.
- 🔁 Use Apify schedules for daily or weekly snapshots.
- 🧩 Match records by `productId` or `catalogueId`, not title alone.
- 🕒 Compare `scrapedAt` timestamps when building price histories.
- 📉 Calculate price changes from numeric INR fields.
- 🛑 Treat a failed run as a source or extraction problem; the Actor does not silently return an empty success.
- 📦 Remember that inventory is a source-exposed signal, not a fulfillment guarantee.

### Scheduling price and stock snapshots

Create an Apify task with your chosen input, then attach a schedule.
A common workflow is one run every morning with results sent through a webhook.
Store each run's dataset in a warehouse keyed by product ID and snapshot time.

Useful alerts include:

- current price dropped below a threshold
- discount increased by more than five percentage points
- product changed from unavailable to available
- membership price changed
- a new product ID appeared in a tracked collection

### Integrations

#### Google Sheets price tracker

Send dataset rows to Google Sheets through Make or Zapier.
Use one sheet for the latest state and another for append-only history.

#### Slack or email discount alerts

Filter rows where `discountPercent` exceeds your target.
Trigger a Slack message or email with the title, current price, and product URL.

#### BigQuery or Snowflake history

Load each scheduled dataset into a partitioned table.
Join on `productId` and compare prices over time.

#### Airtable sourcing queue

Create Airtable records for available products below your sourcing threshold.
Preserve the source URL and scrape timestamp for review.

#### Webhooks

Attach a webhook to the Actor run and start downstream processing as soon as the run succeeds.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/cashify-refurbished-products-scraper').call({
  startUrls: [{ url: 'https://www.cashify.in/buy-refurbished-mobile-phones/lowest-prices' }],
  maxItems: 20,
  followLinkedCollections: true,
  maxCollectionPages: 3,
});

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

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/cashify-refurbished-products-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.cashify.in/buy-refurbished-mobile-phones/apple'}],
    'maxItems': 10,
    'followLinkedCollections': False,
    'maxCollectionPages': 1,
})

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

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~cashify-refurbished-products-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://www.cashify.in/buy-refurbished-mobile-phones/lowest-prices"}],
    "maxItems": 10,
    "followLinkedCollections": false,
    "maxCollectionPages": 1
  }'
```

Fetch dataset items after the run finishes using the returned dataset ID.

### Use Cashify scraper with MCP

Connect the Actor to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/cashify-refurbished-products-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/cashify-refurbished-products-scraper"
    }
  }
}
```

Example prompts:

- “Run the Cashify scraper for the Apple refurbished collection and return the five largest discounts.”
- “Create a table of available Cashify phones under INR 25,000.”
- “Compare current price and MRP for the lowest-price collection.”
- “Save a 50-product Cashify snapshot for my reseller research.”

### Data quality and field semantics

Prices are integers or numbers in Indian rupees.
The Actor calculates discount amount and percentage from current price and MRP.
Availability is `true` when Cashify exposes inventory greater than zero.
Ratings and inventory are omitted if the source does not provide them.

The Actor preserves multiple source price concepts because they may serve different workflows:

- `currentPriceInr`: sale price, falling back to effective price
- `membershipPriceInr`: displayed membership offer
- `effectivePriceInr`: source effective price
- `channelPriceInr`: source channel price
- `mrpInr`: crossed-out maximum retail price

### Error handling and troubleshooting

#### Why did my URL fail immediately?

The Actor only accepts Cashify refurbished-mobile category or collection paths.
Check the hostname and ensure the path starts with `/buy-refurbished-mobile-phones/`.
Individual product detail URLs are outside the collection input contract.

#### Why did the run report no products?

Cashify may have changed its page structure or returned an incomplete response.
Retry once with the public page in a browser.
If products are visible but the Actor still fails, share the run with the Actor developer so the extractor can be updated.

#### Why are fewer products returned than `maxItems`?

`maxItems` is a ceiling, not a promise.
The chosen pages may contain fewer unique products, and duplicates across collections are only saved once.
Enable linked collections or provide more collection URLs for broader coverage.

#### Why is an optional field missing?

Cashify does not expose every field for every product.
Missing optional values are omitted instead of filled with misleading defaults.

### Is it legal to scrape Cashify?

This Actor accesses publicly visible catalog information and does not bypass login controls.
Scraping legality depends on your jurisdiction, intended use, volume, and contractual obligations.
You are responsible for complying with applicable laws, Cashify's terms, privacy rules, and intellectual-property requirements.

Use conservative schedules, avoid collecting personal data, and do not overload the source.
This documentation is not legal advice.

### Limitations

- The v1 scope is public refurbished-mobile category and collection pages on Cashify India.
- Product detail-page specifications and checkout availability are not crawled.
- A collection's server-rendered catalog may expose a bounded set of products.
- Linked discovery follows only public refurbished category links and respects the page limit.
- Source values can change between the scrape and a purchase decision.
- Cashify may change fields or delivery methods without notice.

### Related scrapers

Build a broader commerce intelligence workflow with other automation-lab Actors:

- [Google Shopping Scraper](https://apify.com/automation-lab/google-shopping-scraper)
- [Amazon Product Scraper](https://apify.com/automation-lab/amazon-product-scraper)
- [Flipkart Scraper](https://apify.com/automation-lab/flipkart-scraper)
- [eBay Product Scraper](https://apify.com/automation-lab/ebay-product-scraper)

Choose the Actor that matches the source you need.
Do not substitute another marketplace's fields for Cashify-specific price and inventory signals.

### FAQ

#### Does the Actor require a Cashify account?

No. It uses public catalog pages and does not log in.

#### Does it use a browser?

No for the current v1 route. It parses structured server-rendered data over HTTP.

#### Can I scrape several Cashify brands in one run?

Yes. Add several supported collection URLs or enable linked collection discovery.

#### Are prices returned as strings?

No. INR price fields are numeric, which makes filtering and calculations easier.

#### How are duplicates handled?

The Actor deduplicates products globally by Cashify product ID during the run.

#### Can I schedule it?

Yes. Save the input as an Apify task and attach a daily, weekly, or custom schedule.

#### Can I export to Excel?

Yes. Apify datasets support Excel, CSV, JSON, XML, and other export formats.

#### Does `available` guarantee stock?

No. It reflects the inventory signal exposed by Cashify at scrape time.

#### Can I request more than 10 products?

Yes. Increase `maxItems` and provide or discover multiple collection pages.
Actual output depends on unique products exposed by those pages.

#### Where should I report a problem?

Use the Issues tab on the Actor page and include a shareable run URL, input, and expected result.

# Actor input Schema

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

Add public Cashify refurbished-mobile category URLs. Product detail URLs and non-Cashify URLs are rejected.

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

Stop after saving this many unique refurbished products.

## `followLinkedCollections` (type: `boolean`):

Follow public brand/category links found on each Cashify collection page to broaden catalog coverage.

## `maxCollectionPages` (type: `integer`):

Maximum number of Cashify category or collection pages to request.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.cashify.in/buy-refurbished-mobile-phones/lowest-prices"
    }
  ],
  "maxItems": 10,
  "followLinkedCollections": true,
  "maxCollectionPages": 2
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the default dataset in the product-focused overview table.

# 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.cashify.in/buy-refurbished-mobile-phones/lowest-prices"
        }
    ],
    "maxItems": 10,
    "followLinkedCollections": true,
    "maxCollectionPages": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/cashify-refurbished-products-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.cashify.in/buy-refurbished-mobile-phones/lowest-prices" }],
    "maxItems": 10,
    "followLinkedCollections": True,
    "maxCollectionPages": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/cashify-refurbished-products-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.cashify.in/buy-refurbished-mobile-phones/lowest-prices"
    }
  ],
  "maxItems": 10,
  "followLinkedCollections": true,
  "maxCollectionPages": 2
}' |
apify call automation-lab/cashify-refurbished-products-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Cashify Refurbished Products Scraper",
        "description": "📱 Extract public Cashify India refurbished-device prices, MRP, discounts, ratings, stock, warranty, membership prices, images, and product URLs.",
        "version": "0.1",
        "x-build-id": "mny2qK4htX4zhWhHs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~cashify-refurbished-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-cashify-refurbished-products-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~cashify-refurbished-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-cashify-refurbished-products-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~cashify-refurbished-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-cashify-refurbished-products-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "📱 Cashify category or collection URLs",
                        "type": "array",
                        "description": "Add public Cashify refurbished-mobile category URLs. Product detail URLs and non-Cashify URLs are rejected.",
                        "default": [
                            {
                                "url": "https://www.cashify.in/buy-refurbished-mobile-phones/lowest-prices"
                            }
                        ],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique refurbished products.",
                        "default": 20
                    },
                    "followLinkedCollections": {
                        "title": "Follow linked brand collections",
                        "type": "boolean",
                        "description": "Follow public brand/category links found on each Cashify collection page to broaden catalog coverage.",
                        "default": true
                    },
                    "maxCollectionPages": {
                        "title": "Maximum collection pages",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of Cashify category or collection pages to request.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```