JD APIpmsearch.jd.com ↗
Retrieve judicial auction item details and full bid histories from JD Paimai. Covers pricing, timing, bid counts, and anonymized bidder records via 2 endpoints.
What is the JD API?
This API provides access to judicial auction data from JD Paimai (paimai.jd.com) across 2 endpoints. The get_item_detail endpoint returns 10 structured fields per auction item, including start price in CNY, auction start and end timestamps, bid count, view count, and the presiding court's vendor ID. A second endpoint, get_bid_records, returns the complete bid history with per-bid timestamps, prices, and anonymized usernames.
curl -X GET 'https://api.parse.bot/scraper/79a07681-12da-4ca7-bb65-159b16b09dfd/get_item_detail?item_id=310131146' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace pmsearch-jd-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: JD Paimai SDK — judicial auction item lookup and bid history."""
from parse_apis.jd_paimai_judicial_auction_api import JDPaimai, AuctionItemNotFound
client = JDPaimai()
# Fetch a single auction item by its paimai ID
item = client.auctionitems.get(item_id="310131146")
print(f"Title: {item.title}")
print(f"Current price: {item.current_price}, Assessment: {item.assessment_price}")
print(f"Start price: {item.start_price}, Deposit: {item.ensure_price}")
print(f"Status: {item.auction_status}, Round: {item.location}")
print(f"Bids: {item.bid_count}, Views: {item.access_num}")
# Drill into the item's bid history via the sub-resource
for bid in item.bids.list(limit=5):
print(f" Bid: {bid.price} by {bid.username} at {bid.bid_time}")
# Handle a non-existent item gracefully with typed error
try:
missing = client.auctionitems.get(item_id="999999999999")
print(f"Found: {missing.title}")
except AuctionItemNotFound as exc:
print(f"Item not found: {exc}")
print("Exercised: auctionitems.get / bids.list / AuctionItemNotFound error handling")
Get details for a specific auction item by its paimai ID. Returns pricing, status, timing, location, and other auction metadata. Combines data from the basic info and real-time data APIs. Each item has a numeric paimai_id that uniquely identifies it on the platform.
| Param | Type | Description |
|---|---|---|
| item_idrequired | string | The unique paimaiId of the auction item (numeric string, e.g. '310131146'). |
{
"type": "object",
"fields": {
"title": "string, auction item title/description",
"end_time": "integer, auction end time as Unix timestamp in milliseconds",
"location": "string, auction round prefix (e.g. '一拍' for first auction)",
"bid_count": "integer, total number of bids placed",
"paimai_id": "string, the auction item ID",
"vendor_id": "integer, the court/vendor organization ID",
"access_num": "integer, number of views/visits",
"start_time": "integer, auction start time as Unix timestamp in milliseconds",
"category_id": "integer, the auction category ID",
"start_price": "number, starting auction price in CNY",
"ensure_price": "number, deposit/guarantee amount required in CNY",
"bid_increment": "number or null, minimum bid increment in CNY",
"building_area": "string or null, building area in square meters if applicable",
"current_price": "number, current highest bid price in CNY",
"auction_status": "integer, numeric auction status code",
"assessment_price": "number, assessed/appraised value in CNY",
"auction_status_text": "string or null, human-readable auction status name"
}
}About the JD API
Auction Item Details
The get_item_detail endpoint accepts a item_id — a numeric string matching the auction's paimaiId on JD Paimai — and returns metadata for that listing. Response fields include title (the item description), start_price and bid_count, Unix millisecond timestamps for start_time and end_time, and location which encodes the auction round as a Chinese-language prefix (e.g., 一拍 for first auction, 二拍 for second). The vendor_id field identifies the issuing court or organization, and category_id classifies the asset type. access_num reflects total listing views.
Bid History
The get_bid_records endpoint returns a bids array for the same item_id. Each element in the array contains a bidTime (Unix millisecond timestamp), price (in CNY), and username (an anonymized bidder identifier as displayed on the platform). For auction items that have received no bids yet, the endpoint returns an empty bids array rather than an error, so callers can safely poll active listings without special-casing the zero-bid state.
Coverage and Scope
Both endpoints cover judicial auctions listed on JD Paimai, which handles court-ordered asset liquidations including real estate, vehicles, and other property across mainland China. The location field and vendor_id field together allow callers to segment listings by auction round and originating court, which is useful for tracking assets that have failed to sell and re-entered at a lower starting price.
The JD API is a managed, monitored endpoint for pmsearch.jd.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when pmsearch.jd.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official pmsearch.jd.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Monitor judicial real estate auctions and alert when
start_pricedrops between auction rounds indicated bylocation - Track bid velocity on active auctions by polling
get_bid_recordsand comparingbid_countover time - Aggregate court-specific auction activity by grouping items on
vendor_idto analyze which courts are most active - Build a bid history timeline using
bidTimeandpricefields to visualize price escalation during live auctions - Identify low-competition assets by querying
get_item_detailfor items wherebid_countis zero nearend_time - Calculate auction engagement ratios by comparing
access_num(views) againstbid_countper listing
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does JD Paimai have an official developer API?+
What does the `location` field in `get_item_detail` actually represent?+
location field encodes the auction round as a Chinese-language prefix. A value of 一拍 means first auction, 二拍 means second auction (a re-listing after the first failed to sell), and so on. This lets you identify assets that are being re-auctioned, typically at a reduced starting price.Does the API return the evaluated or appraised value of an auction asset?+
start_price (the opening bid in CNY) but do not expose a separate court-appraised or evaluated valuation field. You can fork this API on Parse and revise it to add that field if the source listing exposes an appraisal figure.Are bidder identities fully exposed in `get_bid_records`?+
username field in each bid record is an anonymized identifier as displayed by JD Paimai — it is not a full name or verified identity. The API returns whatever anonymized label the platform assigns to each bidder.Does the API support searching or listing auctions by category, region, or court?+
item_id. It does not provide a search or browse endpoint to discover items by category_id, vendor_id, or geographic region. You can fork this API on Parse and revise it to add a search endpoint covering those filters.