# Xianyu Goofish Scraper — China Resale Search & Item API (`sian.agency/xianyu-goofish-product-scraper`) Actor

Search Xianyu (Goofish, 闲鱼), China's largest second-hand resale marketplace, by keyword and export clean data: price, condition, location, specs, want-count and full seller profiles. Sortable, paginated search plus item-ID detail lookups. Export JSON, CSV or Excel for price monitoring and research.

- **URL**: https://apify.com/sian.agency/xianyu-goofish-product-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** E-commerce, Marketing, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 1,000 product search results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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

## Xianyu Goofish Scraper — China Resale Search, Item & Seller Data 🛍️

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Taobao & Tmall](https://img.shields.io/badge/Store-Taobao%20%26%20Tmall-FF4F00)](https://apify.com/sian.agency/taobao-tmall-product-scraper?fpr=sian) [![Xiaohongshu RedNote](https://img.shields.io/badge/Store-Xiaohongshu%20RedNote-FF2442)](https://apify.com/sian.agency/xiaohongshu-rednote-scraper?fpr=sian) [![JD.com](https://img.shields.io/badge/Store-JD.com-E3101E)](https://apify.com/sian.agency/jd-com-product-scraper?fpr=sian)

#### 🎉 Search + Item Detail + full Seller profile in ONE actor — the deepest Xianyu (Goofish) data on Apify
##### Built for resellers, arbitrage traders, sourcing teams and market researchers who need clean, structured second-hand marketplace data

---

### 📋 Overview

**Xianyu (Goofish, 闲鱼) is Alibaba's C2C second-hand marketplace — China's largest resale platform with hundreds of millions of users.** This actor searches it by keyword and looks listings up by item ID, returning clean structured rows with prices, condition, location, demand signals and full seller profiles — no account, no API key, no setup.

**Why thousands of professionals choose us:**
- ✅ **Search + Detail + Seller in one tool**: Most scrapers split these across separate actors — here keyword listing search, deep item detail and full seller profiles live in a single actor with one clean dataset.
- ⚡ **Sortable, paginated search**: Sort cheapest-first for arbitrage or newest-first for monitoring, and paginate up to 200 listings per keyword — no manual page-flipping.
- 🎯 **Seller-trust intelligence**: Every Item Detail row carries seller credit tags, Sesame (Zhima) verification, account age, listing count and 24h reply ratio — screen counterparties before you buy or source.
- 💰 **Transparent per-listing / per-item billing**: Pay only for the listings and items you actually receive. Bulk keyword and item-ID input, JSON/CSV/Excel export.
- 💎 **Structured specs & condition**: Brand, model, storage, version, condition and repair status arrive as filterable columns — plus price-drop, want-count, verified-serial and free-shipping flags.
- ✨ **NEW**: Item Detail by ID returns the full description, demand counts (want / browse / collect) and the complete seller profile for deep due diligence.

---

### ✨ Features

- 🔍 **Keyword Listing Search**: Find second-hand listings by any keyword (English or Chinese) with relevance, recency, credit and price sorting.
- 📦 **Item Detail Lookup**: Pull the full listing + seller profile for one or many item IDs.
- ↕️ **7 Sort Modes**: Active, recent, seller-credit, price low→high, price high→low, price-drop and newest.
- 🚀 **Bulk Input**: Single keyword, a keyword list, a keywords-from-file URL, or a list of item IDs in one run.
- ⭐ **Seller Profiles**: Credit tags, Sesame verification, account age, listing count, 24h reply ratio and city.
- 🏷️ **Structured Specs**: Brand, model, storage, version, condition and repair status as discrete fields.
- 💴 **Clean Pricing**: Listed price, original price and shipping fee in CNY, plus the displayed price text.
- 📈 **Demand Signals**: Want-count, browse-count and favourite-count to gauge interest and liquidity.
- 🖼️ **Full Image Galleries**: Cover image plus every listing photo, normalized to HTTPS.
- 📊 **Export Anywhere**: JSON, CSV and Excel straight from the Apify dataset.

---

### 🎬 Quick Start

Pick an operation, enter a keyword (or item ID), and run. Search returns relevance-ranked second-hand listings; Item Detail returns the full listing and seller profile. Results stream into a clean, structured dataset.

```bash
curl -X POST "https://api.apify.com/v2/acts/sian.agency~xianyu-goofish-product-scraper/runs?token=YOUR_TOKEN" \
-H 'Content-Type: application/json' \
-d '{"operation": "keywordSearch", "keyword": "iPhone", "sort": "price_asc", "maxResults": 30}'
````

***

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Choose your operation

Pick **Listing Search** (by keyword) or **Item Detail** (by item ID).

#### Step 2: Enter your input

Type a keyword (e.g. `iPhone`, `Rolex`, `球鞋`) or paste item IDs. Add bulk keywords / IDs to process many at once.

#### Step 3: Run and export

Click **Start** and watch clean rows fill the dataset. Download as JSON, CSV or Excel.

**That's it! In under a minute, you'll have:**

- Relevance-ranked second-hand listings with price, condition and location
- Full item details with structured specs and demand counts
- Complete seller profiles for trust and arbitrage screening

***

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| operation | string | No | `keywordSearch` (default) or `productDetail` |
| keyword | string | No | Single keyword for Listing Search |
| keywords | array | No | Multiple keywords for bulk Listing Search |
| keywordsFileUrl | string | No | Public URL to a text file, one keyword per line |
| sort | string | No | `active`, `recent`, `credit`, `price_asc`, `price_desc`, `price_drop`, `newest` |
| itemId | string | No | Single item ID for Item Detail |
| itemIds | array | No | Multiple item IDs for bulk Item Detail |
| maxResults | integer | No | Max listings per keyword for Listing Search (8–200, default 30) |

**Listing Search example:**

```json
{
  "operation": "keywordSearch",
  "keyword": "Air Jordan 1",
  "sort": "price_asc",
  "maxResults": 50
}
```

**Bulk Item Detail example:**

```json
{
  "operation": "productDetail",
  "itemIds": ["1031168370989", "1052014412765"]
}
```

***

### 📤 Output

Results are saved to the Apify dataset with **25+ fields** including:

| Field | Type | Description |
|-------|------|-------------|
| itemTitle | string | Listing title as posted by the seller |
| itemId | string | Unique Xianyu (Goofish) item identifier |
| priceYuan | number | Listed price in CNY (yuan) |
| originalPriceYuan | number | Original / pre-discount price in yuan |
| transportFeeYuan | number | Shipping fee in yuan (0 = free shipping) |
| area | string | Seller location (province / city) |
| conditionText | string | Item condition label |
| wantCount | number | Users who marked the listing as wanted |
| browseCount | number | Listing views (Item Detail) |
| collectCount | number | Listing favourites (Item Detail) |
| tags | array | Condition, brand, spec, price-drop, verified-serial & shipping flags |
| specs | array | Structured attributes (brand, model, storage, version, condition, repair) |
| itemDescription | string | Full listing description (Item Detail) |
| imageUrl / imageUrls | string / array | Cover image and the full photo gallery |
| itemUrl | string | Public Goofish listing URL |
| sellerNick | string | Seller display name |
| sellerRegDays | number | Days since the seller registered (account age) |
| sellerReplyRatio24h | string | Seller's 24-hour reply ratio |
| sellerZhimaAuth | boolean | Seller has Sesame (Zhima) credit verification |
| sellerCreditTags | array | Seller credit / identity badges |

**Example (Listing Search row):**

```json
{
  "itemTitle": "苹果15国行256g黑色 屏幕少量轻微划痕不影响使用",
  "itemId": "1031168370989",
  "priceYuan": 1997,
  "priceText": "¥1997",
  "shippingText": "包邮",
  "area": "四川",
  "conditionText": "少量磕碰划痕",
  "wantCount": 12,
  "tags": ["少量磕碰划痕", "Apple/苹果", "256GB", "已降553元", "12人想要", "卖家信用极好", "包邮", "已验证序列号"],
  "imageUrl": "https://img.alicdn.com/bao/uploaded/...",
  "itemUrl": "https://www.goofish.com/item?id=1031168370989",
  "_operation": "keywordSearch",
  "_sourceKeyword": "iPhone",
  "status": "success"
}
```

***

### 💼 Use Cases & Examples

#### 1. Resale Price Monitoring

**Resellers tracking second-hand prices across a product roster.**

**Input:** A bulk keyword watchlist + `sort: price_drop` or `price_asc`
**Output:** Listed price, original price, shipping and condition per listing
**Use:** Schedule daily runs to catch price drops and watch the floor on Xianyu / Goofish.

#### 2. Second-Hand Arbitrage Research

**Arbitrage traders comparing China-side resale prices against Western markets.**

**Input:** Keyword search sorted cheapest-first
**Output:** Price, condition, location, shipping and demand (want-count) per listing
**Use:** Spot spreads between Xianyu (Goofish) and platforms like eBay, StockX or Grailed.

#### 3. Seller-Trust Screening

**Buyers and sourcing teams vetting sellers before a deal.**

**Input:** Item IDs via Item Detail
**Output:** Seller credit tags, Sesame verification, account age, listing count, reply ratio
**Use:** Screen counterparties and filter out low-trust sellers automatically.

#### 4. Brand & Condition Tracking

**Category analysts tracking supply and condition for specific brands or models.**

**Input:** A brand/model keyword list
**Output:** Structured specs (brand, model, storage, version, condition, repair status) + verified-serial & free-shipping flags
**Use:** Map how a model's second-hand condition mix and pricing shift over time.

#### 5. Market & Demand Research

**E-commerce researchers sizing the China second-hand market.**

**Input:** Keyword search across categories
**Output:** Listing volume, want / browse / favourite counts and price distribution
**Use:** Quantify supply and demand on China's largest C2C resale marketplace.

***

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/xianyu-goofish-product-scraper').call({
  operation: 'keywordSearch',
  keyword: 'iPhone',
  sort: 'price_asc',
  maxResults: 30
});

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

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/xianyu-goofish-product-scraper').call(
    run_input={'operation': 'productDetail', 'itemIds': ['1031168370989']}
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~xianyu-goofish-product-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"operation": "keywordSearch", "keywords": ["iPhone", "Rolex"], "maxResults": 30}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger**: Schedule or webhook
2. **HTTP Request**: Call the actor API
3. **Process**: Handle the JSON results
4. **Action**: Save to a sheet, alert on price drops, or sync to your database

***

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- Up to **5 keywords or item IDs** per run — full feature access, same data quality
- No credit card required
- Perfect for testing and small projects

#### PAID Tier (Production Ready)

- **Unlimited** keywords and item IDs per run
- Deep pagination (up to 200 listings per keyword)
- Pay-per-result: charged per listing returned (search) or per item (detail)

💰 **Transparent pricing** — you pay for the data you receive, nothing more.

🔗 [View current pricing](https://apify.com/sian.agency/xianyu-goofish-product-scraper?fpr=sian)

***

### ❓ Frequently Asked Questions

**Q: How many listings can I get per keyword?**
A: Up to 200 per keyword on the PAID tier; the actor paginates automatically. FREE runs are limited to 5 keywords/IDs.

**Q: Where do I find an item ID?**
A: It's the numeric `id` in a Goofish listing URL (`goofish.com/item?id=`**`1031168370989`**) and is returned as `itemId` by Listing Search.

**Q: Do searches work with Chinese keywords?**
A: Yes — both English and Chinese keywords are fully supported (e.g. `球鞋`, `相机`, `耐克`).

**Q: What output formats are available?**
A: JSON, CSV and Excel — export directly from the Apify dataset.

**Q: What currency are prices in?**
A: Chinese yuan (CNY). Each row carries the numeric price and the displayed price text.

**Q: Is this legal?**
A: Yes — we only extract publicly available marketplace data. See the legal section below.

***

### 🐛 Troubleshooting

**A search returns an error row**

- The marketplace can briefly fail to collect; the actor retries automatically. Re-run if a keyword still errors.

**Item Detail returns an error for an ID**

- Confirm the item ID is correct and the listing is still live (sold/removed listings can no longer be fetched).

**Fewer results than `maxResults`**

- Some keywords simply have fewer live listings; the actor stops when the marketplace reports no further pages.

**FREE tier limited my run**

- FREE runs cap at 5 keywords / item IDs. Upgrade for unlimited input and deeper pagination.

***

### ⚠️ Trademark Disclaimer

This is an independent tool and is **not affiliated with, endorsed by, or sponsored by** Alibaba Group, Xianyu (闲鱼), or Goofish. "Xianyu", "闲鱼" and "Goofish" are trademarks of their respective owners. This actor accesses only publicly available listing information and is intended for lawful research, monitoring and analysis. All product names, logos and brands are the property of their respective owners.

***

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the **GDPR** in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

***

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, open an issue in the actor's Issues tab
- Check the [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `operation` (type: `string`):

🛠️ **OPERATION:** Choose what to scrape.

🔍 **Listing Search** — find second-hand listings by keyword and export price, condition, location, want-count and seller signals (paginated, sortable).

📦 **Item Detail** — look up one or more listings by item ID for the full description, structured specs (brand/model/storage/condition), demand counts and a complete seller profile.

## `keyword` (type: `string`):

🔍 **SINGLE KEYWORD SEARCH:** Enter one keyword to search the marketplace.

💡 **Examples:** `iPhone`, `Air Jordan 1`, `Rolex`, `PS5`, or Chinese terms like `球鞋`, `相机`, `耐克`.

📦 Returns relevance-ranked second-hand listings with price, condition and seller info.

💡 **TIP:** Use **Bulk Keywords** below to sweep a whole watchlist in one run.

⚠️ Used only when **Operation = Listing Search**.

## `keywords` (type: `array`):

🚀 **BULK KEYWORD SEARCH:** Search many keywords in one run — perfect for monitoring a brand or product watchlist.

📊 **TIER-BASED LIMITS:**

- **FREE users:** Up to 5 keywords per run
- **PAID users:** Unlimited keywords

✏️ **BULK EDIT:** Click "Bulk edit" to paste keywords (one per line).

⚠️ Used only when **Operation = Listing Search**. Provide a single keyword OR bulk keywords.

## `keywordsFileUrl` (type: `string`):

📄 **KEYWORDS FROM A FILE:** Provide a public URL to a plain-text file with one keyword per line. Useful for large, version-controlled watchlists.

📊 Tier limits apply the same as Bulk Keywords (FREE: 5, PAID: unlimited).

⚠️ Used only when **Operation = Listing Search**.

## `sort` (type: `string`):

↕️ **SORT ORDER** for Listing Search results:

- **Active** — active listings first (default)
- **Recent** — recent / position-based results first
- **Seller credit** — high-credit sellers first
- **Price: low → high** — cheapest first (best for arbitrage)
- **Price: high → low** — most expensive first
- **Price drop** — recently reduced-price listings first
- **Newest** — newly listed items first

⚠️ Used only when **Operation = Listing Search**.

## `itemId` (type: `string`):

📦 **SINGLE ITEM DETAIL:** Enter one Xianyu (Goofish) item ID to pull the full listing + seller profile.

💡 The item ID is the numeric `id` in a listing URL (e.g. `https://www.goofish.com/item?id=`**`1031168370989`**) and is also returned as `itemId` by Listing Search.

💡 **TIP:** Use **Bulk Item IDs** below for several at once.

⚠️ Used only when **Operation = Item Detail**.

## `itemIds` (type: `array`):

🚀 **BULK ITEM DETAIL:** Look up many listings by item ID in one run.

📊 **TIER-BASED LIMITS:**

- **FREE users:** Up to 5 item IDs per run
- **PAID users:** Unlimited item IDs

✏️ **BULK EDIT:** Click "Bulk edit" to paste item IDs (one per line).

⚠️ Used only when **Operation = Item Detail**.

## `maxResults` (type: `integer`):

🔢 **RESULT CAP:** Maximum unique listings to return per keyword for **Listing Search** (8–200). The actor paginates the marketplace (≈10 listings per page) until this cap is reached.

💡 Default 30 captures three pages of fresh listings. (Ignored for Item Detail.)

## Actor input object example

```json
{
  "operation": "keywordSearch",
  "keyword": "iPhone",
  "keywords": [
    "iPhone",
    "Air Jordan 1",
    "Rolex"
  ],
  "keywordsFileUrl": "https://example.com/keywords.txt",
  "sort": "active",
  "itemId": "1031168370989",
  "itemIds": [
    "1031168370989",
    "1052014412765"
  ],
  "maxResults": 30
}
```

# Actor output Schema

## `results` (type: `string`):

Matched listings — one flat row per listing (search) or per item (detail) with price, condition, location, demand counts, structured specs and seller-trust signals.

## `scrapingSummary` (type: `string`):

HTML report with run status, success/error row counts, unique items, success rate, duration and the inputs used — written even on fatal crash.

# 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 = {
    "keyword": "iPhone"
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/xianyu-goofish-product-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 = { "keyword": "iPhone" }

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/xianyu-goofish-product-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 '{
  "keyword": "iPhone"
}' |
apify call sian.agency/xianyu-goofish-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Xianyu Goofish Scraper — China Resale Search & Item API",
        "description": "Search Xianyu (Goofish, 闲鱼), China's largest second-hand resale marketplace, by keyword and export clean data: price, condition, location, specs, want-count and full seller profiles. Sortable, paginated search plus item-ID detail lookups. Export JSON, CSV or Excel for price monitoring and research.",
        "version": "1.0",
        "x-build-id": "zw8gxMtAKBBVQ1KjE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~xianyu-goofish-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-xianyu-goofish-product-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/sian.agency~xianyu-goofish-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-xianyu-goofish-product-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/sian.agency~xianyu-goofish-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-xianyu-goofish-product-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": {
                    "operation": {
                        "title": "🛠️ Operation",
                        "enum": [
                            "keywordSearch",
                            "productDetail"
                        ],
                        "type": "string",
                        "description": "🛠️ **OPERATION:** Choose what to scrape.\n\n🔍 **Listing Search** — find second-hand listings by keyword and export price, condition, location, want-count and seller signals (paginated, sortable).\n\n📦 **Item Detail** — look up one or more listings by item ID for the full description, structured specs (brand/model/storage/condition), demand counts and a complete seller profile.",
                        "default": "keywordSearch"
                    },
                    "keyword": {
                        "title": "🔍 Search Keyword (Single)",
                        "type": "string",
                        "description": "🔍 **SINGLE KEYWORD SEARCH:** Enter one keyword to search the marketplace.\n\n💡 **Examples:** `iPhone`, `Air Jordan 1`, `Rolex`, `PS5`, or Chinese terms like `球鞋`, `相机`, `耐克`.\n\n📦 Returns relevance-ranked second-hand listings with price, condition and seller info.\n\n💡 **TIP:** Use **Bulk Keywords** below to sweep a whole watchlist in one run.\n\n⚠️ Used only when **Operation = Listing Search**.",
                        "default": "iPhone"
                    },
                    "keywords": {
                        "title": "🚀 Bulk Keywords (Multiple)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "🚀 **BULK KEYWORD SEARCH:** Search many keywords in one run — perfect for monitoring a brand or product watchlist.\n\n📊 **TIER-BASED LIMITS:**\n- **FREE users:** Up to 5 keywords per run\n- **PAID users:** Unlimited keywords\n\n✏️ **BULK EDIT:** Click \"Bulk edit\" to paste keywords (one per line).\n\n⚠️ Used only when **Operation = Listing Search**. Provide a single keyword OR bulk keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywordsFileUrl": {
                        "title": "📄 Keywords from File URL (Optional)",
                        "type": "string",
                        "description": "📄 **KEYWORDS FROM A FILE:** Provide a public URL to a plain-text file with one keyword per line. Useful for large, version-controlled watchlists.\n\n📊 Tier limits apply the same as Bulk Keywords (FREE: 5, PAID: unlimited).\n\n⚠️ Used only when **Operation = Listing Search**."
                    },
                    "sort": {
                        "title": "↕️ Sort Order",
                        "enum": [
                            "active",
                            "recent",
                            "credit",
                            "price_asc",
                            "price_desc",
                            "price_drop",
                            "newest"
                        ],
                        "type": "string",
                        "description": "↕️ **SORT ORDER** for Listing Search results:\n\n- **Active** — active listings first (default)\n- **Recent** — recent / position-based results first\n- **Seller credit** — high-credit sellers first\n- **Price: low → high** — cheapest first (best for arbitrage)\n- **Price: high → low** — most expensive first\n- **Price drop** — recently reduced-price listings first\n- **Newest** — newly listed items first\n\n⚠️ Used only when **Operation = Listing Search**.",
                        "default": "active"
                    },
                    "itemId": {
                        "title": "📦 Item ID (Single)",
                        "type": "string",
                        "description": "📦 **SINGLE ITEM DETAIL:** Enter one Xianyu (Goofish) item ID to pull the full listing + seller profile.\n\n💡 The item ID is the numeric `id` in a listing URL (e.g. `https://www.goofish.com/item?id=`**`1031168370989`**) and is also returned as `itemId` by Listing Search.\n\n💡 **TIP:** Use **Bulk Item IDs** below for several at once.\n\n⚠️ Used only when **Operation = Item Detail**."
                    },
                    "itemIds": {
                        "title": "🚀 Bulk Item IDs (Multiple)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "🚀 **BULK ITEM DETAIL:** Look up many listings by item ID in one run.\n\n📊 **TIER-BASED LIMITS:**\n- **FREE users:** Up to 5 item IDs per run\n- **PAID users:** Unlimited item IDs\n\n✏️ **BULK EDIT:** Click \"Bulk edit\" to paste item IDs (one per line).\n\n⚠️ Used only when **Operation = Item Detail**.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "🔢 Max Results per Keyword",
                        "minimum": 8,
                        "maximum": 200,
                        "type": "integer",
                        "description": "🔢 **RESULT CAP:** Maximum unique listings to return per keyword for **Listing Search** (8–200). The actor paginates the marketplace (≈10 listings per page) until this cap is reached.\n\n💡 Default 30 captures three pages of fresh listings. (Ignored for Item Detail.)",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```