# Goofish Scraper: Xianyu Listings, Prices & Sellers $1.20/1K (`moggedhq/goofish-xianyu-scraper`) Actor

Collect Goofish (Xianyu, Idle Fish) listings from home and topic feeds or item links. Filter by keyword and watch newly observed listings. Get prices, condition, seller and location where shown. $0.0012 per listing, or $0.12 for 100. Item details $0.0025. No login.

- **URL**: https://apify.com/moggedhq/goofish-xianyu-scraper.md
- **Developed by:** [mogged](https://apify.com/moggedhq) (community)
- **Categories:** E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.96 / 1,000 listings

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Goofish Scraper: Xianyu Listings, Prices & Sellers $1.20/1K

For resellers, sourcing teams and marketplace analysts monitoring Goofish (Xianyu, 闲鱼, Idle Fish). Collect prices from homepage and topic feeds, filter by keyword, look up item links and IDs, and watch for listings your runs have never delivered.

A feed listing costs $0.0012. For example, 100 listings cost $0.12 plus the small run start charge. A detailed item costs $0.0025. No Goofish login is needed.

### Start with a feed sample

1. Keep the default settings to collect up to 20 priced listings from the current home feed.
2. Add Chinese keywords such as 相机 (camera), 镜头 (lens) or 耳机 (headphones). Increase feed pages to sample more cards.
3. In Output, open Listings to compare prices, sellers and cities. Check Coverage for the sample size and any source failures. Export CSV or JSON.

```json
{
  "searchTerms": ["相机", "镜头"],
  "feedPages": 20,
  "maxItems": 25,
  "priceMax": 2000,
  "includeDetails": false
}
```

The Actor matches any supplied term against the title and labels. Each listing appears once, with its matching terms.

In a cloud run using the Console prefill, all 20 delivered listings carried a numeric price. The run charged for 20 listings and one start unit. The coverage record showed one sampled page and zero final source failures.

Ten home feed pages can inspect roughly 200 cards. Repeated cards, filters and watch history reduce the delivered count. Set `feedPages` for the sample size and `maxItems` for the delivery cap.

### Sample a topic feed

Use published topics such as 摄影摄像 (photography and video), 垂钓 (fishing) and 吉他乐器 (guitars and instruments). Enter topic names in `feedTopics` or paste a Goofish `/mach-feeds` link. Topic pages generally show about 30 cards.

```json
{
  "feedTopics": ["摄影摄像", "吉他乐器"],
  "feedPages": 15,
  "priceMax": 2500,
  "maxItems": 75
}
```

Turn on `includeTopicFeeds` to sample home and topic feeds. Duplicate IDs are delivered once. The source link and `feedTopic` show where the row was found. Goofish controls the available topics.

### Look up known items

Use desktop, mobile or legacy item links, or supply listing IDs as strings. The mobile item view adds available seller, condition, city, description, photos and engagement.

```json
{
  "startUrls": ["https://www.goofish.com/item?id=1070747085394"],
  "productIds": ["643683114777"],
  "maxItems": 2
}
```

An item ID and a URL for the same listing count as one item. Item links and IDs trigger detailed lookup directly, regardless of the `includeDetails` setting. To combine lookups with discovery, pair the IDs with feed keywords, the Goofish homepage in `startUrls`, or a `feedPages` value.

Turn on `includeDetails` to enrich feed matches. `discoveryPrice` preserves the card price. `price` and `detailSourceUrl` record the separate item-page observation. Use `detailLevel` to identify enriched rows.

### Inputs

| Input | Behavior |
| --- | --- |
| `searchTerms` | Match any supplied term against the sampled feed. NFKC and case-insensitive matching handles full-width forms and English capitalization. Use written alternatives as separate terms. |
| `startUrls` | Goofish item links, supported legacy item links, published topic links, the homepage, or Goofish search links. A search link contributes its keyword to the feed filters. |
| `productIds` | Known Goofish listing IDs as strings. Use the number shown in the `id` parameter of an item link. |
| `maxItems` | Maximum distinct items delivered across feed and item inputs. Defaults to 20. |
| `feedPages` | Maximum total feed pages across the chosen sources. When omitted, the Actor sizes it from the requested result count and term filters. |
| `feedTopics` | Exact published topic names or Goofish topic IDs. |
| `includeTopicFeeds` | Include the homepage and current topic tabs. With `feedTopics`, include only those topics alongside the homepage. |
| `sort` | `default` retains discovery order. `priceAsc` and `priceDesc` sort sampled prices. `newest` places records with a known listing date first. |
| `priceMin`, `priceMax` | Inclusive price bounds in yuan. When enrichment finds an item-page price, the item-page price must also fall inside the range. |
| `includeDetails` | Enrich selected feed cards using the mobile item view. The Actor keeps the priced feed listing if item details are unavailable. |
| `newListingsOnly` | Save delivered listing IDs in a watch and return newly observed IDs on later runs. |
| `watchId` | A stable name for one saved watch. Use up to 60 letters, digits, underscores or hyphens. |
| `proxyConfiguration` | Automatic by default. The Actor starts with Apify's default proxy and uses China residential if needed. An explicit proxy group, country, custom server or disable is respected. |

Select source order for the first matched rows or select a price sort to compare the items in your sample. With enrichment enabled, a price sort uses the sampled card price for discovery order. The item-page price is stored separately so you can sort the exported records again if it differs.

### Listing output

The dataset contains individual products and a final coverage record. Use rows with `type: "PRODUCT"` for joins and calculations. Standard marketplace fields such as `itemId`, `title`, `price`, `originalPrice`, `currency`, `shopName`, `shipFrom`, `imageUrl`, `detailLevel` and `sourceUrl` can be read alongside Taobao snapshots.

| Field | Meaning |
| --- | --- |
| `summary` | Listing title and observed price, or an explanation on a coverage record. |
| `type` | `PRODUCT`, `NOTE` or `SUMMARY`. |
| `itemId`, `listingId`, `productId` | The same stable Goofish listing ID under marketplace field names. |
| `title`, `description` | Source title or card summary and the description when returned by the item view. |
| `price`, `currency` | Numeric observed price in CNY. |
| `originalPrice`, `regularPrice` | A positive comparison price shown by Goofish, where available. The label is useful for comparison and may reflect the seller's reference price. |
| `discoveryPrice` | The feed price kept on a row enriched from an item link during the same run. |
| `condition`, `conditionLevel` | The explicit source condition label or condition code when the page supplies it. |
| `sellerNickname`, `shopName` | The displayed seller nickname, including Goofish's masking when shown. |
| `sellerCredit` | The public credit label where supplied. |
| `location`, `shipFrom`, `province`, `district` | Available listing or seller origin fields. Use them to group locations in exports. |
| `wantCount`, `viewCount` | Numeric engagement metrics where the listing view supplies them. |
| `categoryId`, `labels` | Source category ID and selected text labels. |
| `imageUrl`, `images` | The main image and available listing image links. |
| `url`, `sourceUrl`, `detailSourceUrl` | Canonical item link and the page where the observation came from. |
| `sourceType`, `detailLevel` | `feed` for a card snapshot or `item` for the mobile item view. |
| `sourceQuery`, `matchTerms` | First matching filter term and all matching terms when applicable. |
| `feedTopic` | Published Goofish topic that supplied the card, when applicable. |
| `createdAt`, `publishedAt`, `scrapedAt` | Source creation time or publication time when reported, and the UTC time the Actor read the listing. |
| `missingFields`, `notes` | Important fields missing from the source and any row-specific coverage note. |

The Coverage view links the result to its inputs. The final `SUMMARY` is also saved in the key-value store. It includes delivered item and feed counts, the pages and cards inspected, previously observed IDs, exclusions, source failures and the spending-limit result. Keep it alongside each export so you can distinguish a successful scan with no matches from a source request failure.

### Monitor on a schedule

Save a task with the same `watchId` and set it to run on an Apify schedule. Use a different ID for each combination of keywords and price bounds you want to track independently.

```json
{
  "watchId": "camera-under-2000",
  "newListingsOnly": true,
  "searchTerms": ["相机", "镜头"],
  "priceMax": 2000,
  "feedPages": 25,
  "maxItems": 100
}
```

The first run delivers the baseline visible in your sampled pages. Later runs compare their finds with delivered IDs and return the ones the watch has not seen before. If you only want alerts after establishing your baseline, enable notifications after the first run. For a price history on a fixed list of known items, run those IDs with the watch option off and retain each run's timestamp.

Changing keywords while reusing the same watch ID keeps the existing history. Create a fresh watch ID when you want a separate baseline. Each watch remembers the most recent 25,000 delivered IDs. One run can update a watch at a time. If a run overlaps another for the same ID, its coverage note tells you the watch was busy.

### Cost and spending limits

The Actor bills one listing or one detailed item for each distinct priced row. At the displayed price, 20 feed listings are $0.024, and 20 detailed items are $0.05. The small $0.0005 start charge is separate. Your Apify plan tier can change the listing price applied to the run. If a feed match has no usable detail, the feed price applies. Notes, summaries, repeated IDs and excluded items have no listing charge.

Set Apify's maximum charge alongside `maxItems` for a money cap. The Actor checks whether the next priced row fits that cap and stops cleanly when it cannot deliver another eligible item. Keeping the page sample modest helps reduce work where the source has few matching items.

### Use the API

Send JSON input to Apify with your own API token and save the returned run ID and dataset ID. Run status and coverage are available from the run and its associated storage.

```bash
curl -X POST 'https://api.apify.com/v2/acts/moggedhq~goofish-xianyu-scraper/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  --data '{"feedPages":3,"maxItems":20}'
```

After the run succeeds, read your dataset from `GET /v2/datasets/<datasetId>/items`. For repeat collection, join runs by `itemId` and retain `scrapedAt`, `sourceType` and `currency` so you can compare like observations. The Overview and Coverage views select common columns for spreadsheet export. Raw JSON includes all fields.

### Use with AI agents (MCP)

Connect an agent to your Apify account using Apify MCP. Ask it to find the Goofish Scraper and describe a bounded request. For example, ask for 20 priced listings from the Goofish feed and a coverage summary, then specify an item ID for a detailed follow-up. You can also provide Chinese keywords and a maximum CNY price. Have the agent read the coverage summary alongside the listing rows before drawing conclusions about the sample.

### Limits

Keyword matching covers the sampled public home and topic feeds. Native marketplace-wide search and a comprehensive newest-first feed are unavailable. Listing counts and exact coverage vary by the feed and proxy route. A newly observed ID may be an older listing that the feed has just surfaced. Most cards do not carry a publication timestamp. Item links and IDs can return no data when the item has been removed, requires login or has no numeric price. Short redirect links, checkout prices, current stock guarantees, coupon calculations and account-only fields are unavailable. Prices reflect the source when read and may differ between a feed card, an item page and a specific variant. Unknown values remain null.

### FAQ

**How do I get more exact matches?** Use product names in Chinese, add aliases as separate terms and raise `feedPages`. For a known item, paste its full item link or numeric ID.

**Can I watch the same listing every day?** Yes. Save its item ID and repeat the lookup with the watch option off. The watch option is for discovering IDs across repeated runs.

**What counts as a duplicate?** An identical listing ID is a duplicate within a run, even when it matches several terms or also appears as an input link. Across runs, duplicate suppression applies when the same watch ID is used.

**What should I read when a run returns zero rows?** Open the `SUMMARY` record. It shows whether there were no matches, no newly observed IDs, insufficient spending allowance or a source request problem.

# Actor input Schema

## `searchTerms` (type: `array`):

Match any keyword in the sampled feed title or labels. Try 相机 for cameras or 耳机 for headphones. Chinese terms usually match more.

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

Goofish desktop or mobile listing links, legacy item links, the homepage, a search link or a published Goofish topic feed link.

## `productIds` (type: `array`):

Known item IDs as strings. Each ID requests mobile item detail.

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

Sort the collected sample. Newest uses available listing times and leaves unknown dates last.

## `priceMin` (type: `number`):

Keep prices at or above this CNY amount.

## `priceMax` (type: `number`):

Keep prices at or below this CNY amount.

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

Limit distinct delivered listings across the run.

## `feedPages` (type: `integer`):

Total pages inspected across selected feeds. The home feed usually returns 20 cards and published topics about 30. Increase for more narrow matches.

## `includeDetails` (type: `boolean`):

Look up matching item pages for description, seller, condition, city and engagement where shown. Item links or IDs always request detail.

## `newListingsOnly` (type: `boolean`):

Remember delivered listing IDs for the supplied watch ID. The first run delivers a baseline; future runs emit unseen IDs.

## `watchId` (type: `string`):

Use a stable ID across runs of one watch. Use letters, digits, underscores or hyphens.

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

Automatic mode starts with the default Apify proxy and tries China residential when the source is unavailable. An explicit proxy selection, country or disable is respected.

## `feedTopics` (type: `array`):

Sample specific topic tabs by exact names or IDs, for example 摄影摄像 (photography) and 垂钓 (fishing). Goofish controls the available topics.

## `includeTopicFeeds` (type: `boolean`):

Sample the homepage and the current topic tabs. Supply topic names to pick specific tabs. Useful for a broader sample.

## Actor input object example

```json
{
  "sort": "default",
  "maxItems": 20,
  "feedPages": 3,
  "includeDetails": false,
  "newListingsOnly": false,
  "includeTopicFeeds": false
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "maxItems": 20,
    "feedPages": 3,
    "includeDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("moggedhq/goofish-xianyu-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 = {
    "maxItems": 20,
    "feedPages": 3,
    "includeDetails": False,
}

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

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 20,
  "feedPages": 3,
  "includeDetails": false
}' |
apify call moggedhq/goofish-xianyu-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,moggedhq/goofish-xianyu-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/XvL6gBByd8LOg8yQY/builds/gBTPq8yUQunRRdUME/openapi.json
