Xiaohongshu API Pricing Per 1000 Requests

What Xiaohongshu note and comment data costs across three routes: the official open platform, open-source scripts, and pay-per-call APIs, with measured EveryInfra numbers.

Hand-drawn illustration on graph paper: a long receipt of note snippets with hearts and short lines stands on the left; on the right three price tags hang at descending sizes, the shortest one filled yellow, with a magnifier resting across them.

Pulling the same public notes and comments from Xiaohongshu costs wildly different amounts depending on the route. The official open platform (open.xiaohongshu.com) serves merchants and service providers: it wants an enterprise qualification, per-capability approval, and a review cycle, and it does not retail note or comment content per call. Open-source scripts are free as code (MediaCrawler has more than 42,000 stars), but you run the servers, proxies, and login sessions yourself, and you rewrite the signing code every time the app changes. Pay-per-call third-party APIs list public prices of $10 to $38 per 1,000 requests. We measured EveryInfra's xiaohongshu/* capabilities on 17 November 2026: standard capabilities charge a fixed $0.005556 per request, and the response's own per_1k field reports $5.556 per 1,000 requests, about 1.8 times cheaper than the lowest public third-party price, with failures and empty results free, no monthly fee, and a balance that never expires.

Prices are stated in two units: per 1,000 requests (which maps directly to the published rate) and per 1,000 rows (the per-request charge divided by the rows that request returned). Every number on our side comes from real calls made on 17 November 2026. The three external routes use public material only: official docs, GitHub, company sites, and public pricing pages, each with a read date.

Concept illustration: on the left, from top to bottom, a closed padlock, a toothed gear, and a stack of yellow coins stand for the official platform's qualification barrier, the open-source route's maintenance cost, and the pay-per-call price; three dotted lines run from them to a dark data card on the right that carries a teal title bar and a few placeholder lines, with one of three dots at the bottom coloured teal.
Three routes reach the same public data: the official platform gates on qualification, open-source gates on maintenance, pay-per-call gates on unit price. | source: EveryInfra illustration

The three routes in one table

The table below puts the three routes and our measurement side by side, all converted to a per-1,000-request basis. The official open platform column says "not retailed per call" because it has no public, per-call content data endpoint. The open-source column says "code is free" because it ships code rather than data, with the real spend on servers and upkeep. The pay-per-call column takes three public pricing pages at their 17 November 2026 prices, referred to generically as a pay-per-call API.

RoutePer 1,000 requestsBillingFailures / emptyMinimum spendMCP / AI ready
Official open platformNot retailed per callBy QPS, by capability grant—Enterprise qualification + reviewNo (merchant data)
Open-source scriptsFree code, no per-call priceYour own servers and proxiesYou handle itServer + proxy + upkeepYou wrap it yourself
Pay-per-call third-party API$10–$38Per request (success only)Mostly success-onlySome require a minimum or monthly feeVaries
EveryInfra (measured)$5.556Per request ($0.005556/call)Failures and empty results freeNo monthly fee, no minimumRemote MCP, tool names everyinfra_*

Only the last row is measured. The other three come from public material. To read the table, keep one thing in mind: 1,000 requests is not the same as 1,000 rows. Most Xiaohongshu capabilities return one page per request, roughly 15 to 20 rows, and you pass a page_token to fetch the next page. So the same $0.005556 buys 20 rows for search, 15 for comments, and one account object for a profile. Spreading the charge over the rows is where the differences appear, and the per-1,000-rows section below works each one out.

Horizontal bar chart of US dollars per 1,000 requests: EveryInfra standard $5.556 (teal, shortest), third-party lowest $10, third-party median $12, our Pugongying tier $16, third-party high $38. Axis runs 0 to 40 dollars. Note: the official open platform does not retail this content data and open-source has no per-call price, so neither appears.

Unit one: per 1,000 requests, we are $5.556

Our price is not a figure from a web page. It is what the API returns at call time. At 00:20:24 Singapore time (SGT) on 17 November 2026, a xiaohongshu/search call for the keyword "skincare" returned 20 notes, with billing.charged_usd of 0.005556 and billing.amount.per_1k.USD of 5.555556 in the same response. In other words, $5.556 per 1,000 requests is not our arithmetic. The API reports it. This round made 11 billed successful requests across eight capabilities, xiaohongshu/search, xiaohongshu/search_users, xiaohongshu/profile, xiaohongshu/user_posts, xiaohongshu/note, xiaohongshu/comments, xiaohongshu/product_search, and xiaohongshu/reviews, and every successful request charged $0.005556, matching the price_usd for those capabilities in the free catalog (EveryInfra catalog, read 17 November 2026).

Screenshot of a real API response. The top half is the request: POST /api/v1/social with platform xiaohongshu, action search, and keyword skincare. The bottom half is the 200 response at 00:20:24 Singapore time on 17 November 2026: count is 20, boxed in teal; two notes with their likes, comments, and saves; and at the bottom a billing block with charged_usd 0.005556 and per_1k USD 5.555556, both boxed in teal.
One search request returns 20 rows and charges $0.005556 once; the API's own per_1k field gives $5.556 per 1,000 requests (balance and other internal fields omitted, commenter names hidden). EveryInfra API response, Xiaohongshu keyword search

The catalog lists 17 Xiaohongshu capabilities, all available=true on the day. Apart from one "Pugongying note search" (xiaohongshu/pgy_content_square) at $0.016 per request ($16 per 1,000), the other 16 are $0.005556 each. So whether you query search, profile, note, comments, users, topics, or products, the price is the same: one request, one price, with no extra charge by field count or feature flag. That differs from per-row billing: with per-row billing a fuller page lowers the unit price and a thin page raises it. With per-request billing, returning 1 row and 20 rows cost the same.

Set the public pay-per-call prices beside this. One pay-per-call RedNote data API states "note endpoint from $12.00 per 1,000 requests, billed per request, no subscription and no monthly minimum" and says the cheapest endpoint is $10 per 1,000 (third-party RedNote API docs, read 17 November 2026). Another states "lowest price $0.01 per request", which is $10 per 1,000, and charges "only for successful requests" (third-party RedNote API docs, read 17 November 2026). A third bills in credits at "5 credits per call", which it converts to "roughly £0.01 to £0.03 per call", about $13 to $38 per 1,000 (third-party Xiaohongshu API docs, read 17 November 2026). Together, the public pay-per-call range lands at $10 to $38 per 1,000 requests, with the cheapest tier at $10.

Range chart, horizontal axis US dollars per 1,000 requests from 0 to 40. A grey band marks the third-party pay-per-call range $10 to $38; a teal dot sits at $5.556, to the left of the whole band. Note: our point is left of the cheapest third-party, about 1.8 times cheaper.

The multiples against each public tier look like this:

Public third-party tierPer 1,000 requestsOursTimes cheaper
Lowest$10$5.5561.8x
Median$12$5.5562.16x
High$38$5.5566.84x

So per 1,000 requests, our $5.556 is about 1.8 times cheaper than the lowest public third-party price of $10, about 2.16 times cheaper than the $12 median, and about 6.84 times cheaper than the $38 high tier. The gap is not dramatic, but it is consistent: our point sits to the left of the whole public third-party band. What often matters more than the headline rate are the things around it, whether failures and empty results are charged, whether there is a minimum top-up, whether the balance expires, and whether it plugs into AI tools, and the sections below work through each.

Unit two: per 1,000 rows, worked out by capability

The charge per request is fixed, but the rows per request are not, so "per 1,000 rows" has to be computed per capability. The formula is simple: per 1,000 rows = unit price $0.005556 divided by rows returned, times 1,000. Feed in the day's measured row counts and you get the table below. Search returns 20 rows, which is $0.278 per 1,000. Comments returns 15, which is $0.370 per 1,000. Product reviews return 20, which is $0.278 like search. User posts return 20, also $0.278. Profile and note detail return one object per call, so per 1,000 rows equals per 1,000 requests, $5.556.

CapabilityRows per requestPer 1,000 rowsCall time (SGT)Measured return
xiaohongshu/search20 rows/page$0.27800:20:24skincare, 20 rows
xiaohongshu/user_posts20 rows/page$0.27800:22:04a brand account, 20 rows
xiaohongshu/reviews20 rows/page$0.27800:28:06a face mask, 20 rows
xiaohongshu/product_search18 rows/page$0.30900:27:34face mask, 18 rows
xiaohongshu/comments15 rows/page$0.37000:22:52a brand note, 15 rows
xiaohongshu/profile1 object$5.55600:21:55a brand account
xiaohongshu/note1 object$5.55600:22:43a brand note
Horizontal bar chart of our US dollars per 1,000 rows: search $0.278 (teal), reviews $0.278, user posts $0.278, comments $0.370, profile or note $5.556. Axis runs 0 to 6 dollars. Note: profile and note detail return one object per call, so per 1,000 rows equals per 1,000 requests.

The table makes the difference between per request and per row concrete. If you want data in bulk, a batch of notes under a keyword, a batch of comments under a note, a batch of reviews under a product, then 1,000 rows costs about a quarter of a dollar, because each request returns a whole page. If you want objects one at a time, a specific account profile, a specific note's full body, each call returns one, and per 1,000 rows climbs back to $5.556. Before switching, decide which your work is: pulling content in bulk is far cheaper under per-request billing, while fetching detail object by object leaves the two billing styles close.

One note: these capabilities have no limit parameter in our catalog. Paging goes through page_token, so "20 per page" is the platform's natural page size, not a cap we set. We added a limit: 200 to a xiaohongshu/comments request and it still returned 15 rows and still charged $0.005556, with limit ignored, no error, and no extra charge. To get more comments, pass the next_page_token and request again, with another $0.005556 per page.

Paging and de-duplication: how many rows are new

Since depth comes from paging, you need to know whether paging repeats. At 00:27:04 SGT on 17 November 2026 we used the previous page's page_token to fetch the second page of the "skincare" search and got 20 more rows. De-duplicated by note id, the 40 rows had 0 duplicates, so the two search pages do not overlap at all and all 40 are new. Comment paging overlaps slightly: on the same brand note, page one at 00:22:52 returned 15 rows and page two at 00:27:16 returned 15, and after de-duplication by id 27 rows remained, with 3 repeats, a 10% overlap.

Horizontal stacked bar chart, two groups. Search skincare, two pages: 40 new, 0 duplicate. Comments on a brand note, two pages: 27 new, 3 duplicate. Teal is new rows, grey is duplicates. Note: search pages do not overlap, comment pages overlap about 10 percent, de-duplicated by id.

So when paging by page_token, search can be pulled page after page without worrying about repeats, while comments need de-duplication by id to drop the roughly one-in-ten overlap. Recomputed on unique rows, two comment pages of 30 returns leave 27 unique, about $0.411 per 1,000, roughly 11% above the single-page $0.370, and still far below per-row third-party billing. For a job that needs every comment, this overlap cost is negligible. The real constraint is the absence of a parameter to pull hundreds at once, so deep-paging a hot note takes several requests, each at $0.005556.

Content shifting is the other thing to watch. For the same keyword "skincare", we searched at 00:20:24 and again at 00:38:38, each returning 20 rows, with only 1 row in common. The price was $0.005556 both times, rock steady, but the results are "a batch at that moment", not a fixed list. For trend or sentiment monitoring, fetch several times at set intervals and accumulate de-duplicated by id. Under per-request billing this is cheap, and fetching a keyword 10 times a day is only $0.056.

What the data looks like: fields and freshness

Price is one side. The other is how complete and how fresh the data this money buys is. The fields each capability returns line up with the response_fields for that capability in the free catalog (EveryInfra catalog, read 17 November 2026). Search (xiaohongshu/search) returns 30 fields per note, including id, url, title, text, like_count, collect_count, comment_count, share_count, posted_at, author_name, author_id, is_video, is_goods_note, is_cooperation_note, author_is_verified, poi_id, and poi_name. Comments (xiaohongshu/comments) return id, text, like_count, posted_at, ip_location, author_name, sub_comment_count, is_author, and author_is_ai_agent. Profile (xiaohongshu/profile) returns nickname, red_id, follower_count, following_count, post_count, like_collect_count, ip_location, is_verified, and verification_type. Product reviews (xiaohongshu/reviews) return rating, rating_scale, service_rating, logistics_rating, sku, and posted_date. The author attribution, IP location, cooperation-note flag, and shopping-note flag that sentiment work needs are all in the fields.

CapabilityKey fields (selected)What it answers
xiaohongshu/searchis_goods_note, is_cooperation_note, poi_name, author_is_verifiedHow much of a batch is shopping, cooperation, or store content
xiaohongshu/commentsip_location, sub_comment_count, author_is_ai_agentComment geography, how many carry replies, suspected bot comments
xiaohongshu/profilefollower_count, post_count, verification_type, ip_locationAccount size, verification type, location
xiaohongshu/reviewsrating, service_rating, logistics_rating, skuProduct reputation, service and logistics ratings, feedback by SKU

Freshness shows directly in the calls. The "skincare" page on 17 November 2026 held notes posted 2026-11-15, 2026-11-14, 2026-11-12, 2026-11-10, and 2026-11-09. The brand account's recent posts spanned 2026-11-13, 2026-10-29, and 2026-10-24. The face mask's reviews included one posted 2026-11-16. So the money that day bought that day's content, not a six-month-old snapshot. For trends and sentiment this matters: the closer the timestamps, the better the read.

Pulling this in Python needs no signing work. A standard HTTP request does it, with the standard-library urllib.request or the third-party requests, which is on PyPI:

python
import requests
r = requests.post("https://api.everyinfra.com/api/v1/social",
    headers={"Authorization": f"Bearer {KEY}"},
    json={"platform": "xiaohongshu", "action": "search", "params": {"keyword": "skincare"}})
data = r.json()
print(data["count"], data["billing"]["charged_usd"])  # 20 0.005556
# paging: params["page_token"] = data["next_page_token"], then POST again

Compared with the open-source route, what is saved here is exactly the signing, device registration, login session, and proxies, the parts an open-source script has to rebuild after every app update. Field stability helps too: the same capability returns the same field structure across calls, so your parser is written once instead of chasing platform changes.

Route one: the official open platform, and why per-call content data is out of reach

The official open platform is often assumed to be a ready content API, but that is not its role. It serves merchants and service providers across commerce, content management, and advertising, and its most common use is a merchant feeding orders into their own ERP for unified fulfilment and inventory (CNDev on the Xiaohongshu open platform, read 17 November 2026). Access means registering a developer account, creating an app, requesting each capability's permission separately, signing calls with an AppKey and secret, and getting merchant authorization for merchant data. The docs state plainly that it "needs an enterprise qualification, permissions are requested separately with a stated purpose, and review takes time". This is a channel for qualified merchants and service providers, not a shelf where an individual buys public notes per call.

The official signing scheme confirms the business-to-business shape. The "get item list" example sorts the query and header parameters alphabetically, joins them, appends the app secret, and runs MD5 to produce the sign, sent with the app-key and timestamp (Xiaohongshu School, open-platform request signing, read 17 November 2026). The flow itself is not hard. The hard step is before it: getting the app-key means passing an enterprise qualification and app review first. For a team that wants to pull public notes and comments in bulk for research or sourcing, this route's "cost" is not a per-1,000 figure but a qualification, a review cycle, and access limited to merchant-authorized data.

The "Xiaohongshu note-detail API" tutorials that circulate in developer communities mostly describe third-party collection rather than the official scheme. One comparison draws the two routes clearly: the official open platform suits enterprises and verified developers and needs an enterprise qualification, while third-party collection suits individual developers and small teams with a lower bar but their own risk control to handle (CRMEB on Xiaohongshu note-detail APIs, 17 June 2026). Other tutorials walk through a wrapped "qualification, OAuth2.0, QPS-based calls" flow (Tencent Cloud developer community, 31 August 2026) and competitor analysis using note-detail and post-list endpoints (Alibaba Cloud developer community, 9 January 2026). All of this says the same thing: the compliant official channel has a real qualification-and-authorization gate, not a same-day sign-up.

Compliance is another layer. The open platform requires that use of user and consumer information follow platform rules and personal-information law, which rests on the Personal Information Protection Law (NPC, PIPL), the Data Security Law (NPC, DSL), and the Network Data Security Management Regulations (Cyberspace Administration of China). Merchants on the open platform and mini-programs also clear the MIIT ICP filing (MIIT filing). For teams putting data to commercial use, compliance is a baseline on all three routes. The official channel simply turns it into an entry requirement.

Route two: open-source scripts, where free code is not free data

Open-source scripts are the lowest bar and the easiest cost to underestimate. The most representative is MediaCrawler, a collection tool for Xiaohongshu, Douyin, Kuaishou, Bilibili, Weibo, Tieba, and Zhihu, with more than 42,000 stars on GitHub. Its approach launches a browser with Playwright, keeps the login session, and reads the signing parameters through a JS expression, which the project says "avoids reverse-engineering the complex encryption and lowers the technical bar". Another widely cited one is ReaJason/xhs, a wrapper around Xiaohongshu's web endpoints that is also on PyPI as pip install xhs (xhs on PyPI, read 17 November 2026).

The code is free, but running it costs money and people. MediaCrawler's default mode connects to your existing Chrome (version 144 or newer), enables remote debugging, logs in by QR code, and wants an IP proxy pool to lower detection (MediaCrawler readme, read 17 November 2026). Those add up to the real cost: a server that can run a browser long-term, residential or rotating proxies billed per usage or per month, one or more Xiaohongshu accounts (with a ban risk), and the most expensive item, engineering time. The community puts the upkeep bluntly: when the platform updates its signing algorithm, a pure reverse-engineering approach "breaks and is very expensive to maintain", and even a browser-based approach has to track front-end JS changes (Juejin, a deep dive on MediaCrawler, 2026).

There is also a compliance and authorization layer the open-source authors state themselves. MediaCrawler's disclaimer says it is "for study and reference only, commercial use prohibited" and asks users to follow the Cybersecurity Law and other rules. The ReaJason repository prominently warns that "web crawling may be considered illegal". That is not boilerplate: using an open-source script for commercial collection puts the legal responsibility on you. The project's issue tracker keeps logging login expiry, signing updates, and proxy bans (MediaCrawler Issues, read 17 November 2026). Open-source is not priced per request: the code is free, the data is not. You pay the sum of servers, proxies, accounts, and upkeep, plus the risk you carry.

What this route costs youWhat it isWho carries it
ServerA machine that runs Chrome long-term (CDP mode)Monthly cloud bill
Proxy poolResidential or rotating proxies to lower detectionPer-usage or monthly proxy bill
AccountsLogin sessions, QR login, with ban riskYour own account farming
UpkeepSigning breaks on app updates, you track itYour engineers' hours
ComplianceDisclaimer bars commercial use, risk is yoursThe user

The open-source route's hidden cost is also in how it runs. MediaCrawler recommends CDP mode connecting to your already-logged-in Chrome, reusing its cookies and session to lower detection, but the price is a machine with a browser logged in and kept current. Those hours are hidden. They appear in no per-1,000 rate, but they are the open-source route's real monthly cost. The judgement is simple: if you are a researcher or a student with small volume and can patch code anytime, open-source is cheapest. If you need stability, volume, and data wired into a product, the hidden cost of running this yourself often exceeds a pay-per-call API, and the risk sits with you.

Route three: pay-per-call third-party APIs, public prices of $10 to $38 per 1,000

A pay-per-call third-party API wraps the dirty work of the open-source route: signing, device registration, risk-control, and paging are its job, and you just send HTTP requests. The price for that is the unit cost. One third-party states the trade-off plainly: building your own collection means "reverse-engineering request signing and redoing it whenever the app updates", "handling risk control, CAPTCHAs, and access limits yourself", "endpoints and fields that change without notice, so someone has to maintain it", and "servers, proxies, and other infrastructure that cost extra", while its API lets you "make your first call in minutes" and is "pay per call, charged only for successful requests, with no monthly fee" (third-party RedNote API docs, read 17 November 2026). That paragraph also explains where the open-source unit saving goes: into your own upkeep.

On price, unit one already gave the range: three public pricing pages at 17 November 2026 prices run $10 to $38 per 1,000, cheapest tier $10. The billing details vary and are worth a look. One bills a US-dollar wallet, with the note endpoint from $12 per 1,000, and states that "some failed wallet-funded requests incur processing charges we pass through at cost, with the error response showing the amount charged" (third-party RedNote API pricing, read 17 November 2026), so not every failure is free. Another stresses "charged only for successful requests". The credit-based one gives new accounts 100 free credits, 5 credits per call, a ceiling of 600 requests per minute and 50 concurrent, and does not charge credits on a cache hit (third-party Xiaohongshu API docs, read 17 November 2026).

What to checkPay-per-call third-party API (public material)EveryInfra (measured)
Per 1,000 requests$10–$38$5.556
Billing unitPer request / per creditPer request ($0.005556/call)
Failures / emptyMostly success-only, some charge a failure feeFailures and empty results free
Free allowanceSome give free creditsTest key available
Minimum spendSome require a minimum or monthly feeNo monthly fee, no minimum
AI toolsVariesRemote MCP, tool names everyinfra_*

Read against our measurement, the conclusion is that pay-per-call third-party APIs use the same billing style as we do (per request, success-only), so they are directly comparable. Our unit price sits to the left of their range, cheaper by about 1.8 times to start. Note that each third-party differs in fields, success rate, and latency, and we have not signed up for or bought any of them, so we use only their public rates and do not compare field detail. Nothing here suggests our data comes from any of them, or that the fields match.

Beyond unit price, three things change the monthly bill and are worth counting together when choosing. The first is minimum spend. Among pay-per-call APIs, some give a free allowance and top up as you go, while others require a monthly plan or a minimum top-up, and in light months a monthly fee lifts the effective cost per call. One third-party wrote the three things enterprise procurement cares about into its docs, postpaid billing, invoices with the company's legal entity, and line-by-line reconciliation, which tells you larger customers tend to be on prepaid or postpaid plans rather than pure pay-as-you-go. The second is how failures are counted. Some charge a processing fee on requests that "look valid but error", so you read the error count on the bill. Our side charges nothing for failures and empty results, removing that uncertainty. The third is latency and success rate. In public material, one API reports about 97% success over 30 days and a roughly 1.7-second median response, its own measurements that vary by capability and time of day, so test with your own sample before a bulk run. Together these often decide your real monthly outlay more than the headline rate.

For data teams, per-request billing has one more benefit: parameters do not pull the bill around. Under per-row or per-feature billing, adding a date filter, changing a sort, or pulling one more layer of replies can each be an extra charge, so the bill moves with parameters. Under per-request billing those parameters cost the same $0.005556 whether you use them or not, and you only count request calls. It also makes a staged rollout simple: validate fields and coverage with a few dozen requests, then scale by day, without a parameter doubling the unit price mid-way.

Our measurement, row by row

Laying out the numbers used above gives this round's record of 11 billed successful requests ($0.005556 each, $0.061116 in total) plus one request that returned 503 and was not charged. Times are Singapore time, made in three windows spanning 18 minutes. Targets were brand and institutional accounts only (a cosmetics brand's official account, a face-mask product). Individual creators' handles and ordinary commenters' names are hidden.

CapabilityTime (SGT)ReturnCharge
xiaohongshu/search skincare00:20:2420 rows$0.005556
xiaohongshu/search_users a brand00:20:3420 accounts$0.005556
xiaohongshu/profile a brand account00:21:551 account, 1,828,871 followers$0.005556
xiaohongshu/user_posts a brand account00:22:0420 notes$0.005556
xiaohongshu/note brand note (posted 2026-11-13)00:22:431 note, 68 comments$0.005556
xiaohongshu/comments page 100:22:5215 rows$0.005556
xiaohongshu/search skincare page 200:27:0720 rows (0 overlap with page 1)$0.005556
xiaohongshu/comments page 200:27:1615 rows (3 overlap with page 1)$0.005556
xiaohongshu/pgy_content_square Pugongying content square00:27:23returned 503, not charged$0
xiaohongshu/product_search face mask00:27:3418 products$0.005556
xiaohongshu/reviews a face mask00:28:0620 reviews$0.005556
xiaohongshu/search skincare retest00:38:3820 rows (1 overlap with first)$0.005556
Screenshot of a real API response. The top half is a profile return: a brand official account, verification_type business, follower_count 1828871 boxed in teal, charged_usd 0.005556. The bottom half is a comments return: two comments with their likes and replies, 15 rows per page boxed in teal, charged_usd 0.005556. Commenter names are hidden.
Profile returns one object and comments return 15 rows per page, each charging $0.005556 once; commenter names are hidden in this screenshot. EveryInfra API response, Xiaohongshu profile and comments

A few calls are worth singling out. xiaohongshu/profile on a cosmetics brand's official account returned follower_count 1,828,871, post_count 593, verification_type business, and ip_location Guangdong, for $0.005556. xiaohongshu/reviews on a face mask selling 180,000 units returned 20 reviews with rating, rating_scale, service_rating, and logistics_rating, the latest review dated 2026-11-16, also $0.005556. Whichever comes back, an account profile, a note body, or a product review, one request is the same price.

Products deserve a look, because they connect content and commerce. xiaohongshu/product_search for "face mask" returned 18 products with price, original_price, sold_count, and shop_name, one of them the same mask selling 180,000 units whose reviews, broken out by SKU, appear above. For a sourcing or competitor team, this set answers "does a category sell well, where is the reputation, where do logistics get complaints" in one pass, each request still $0.005556. Product prices are Xiaohongshu's on-site figures in yuan, which are the platform's market data. Our API fee is charged per request and is unrelated to the product price. String search, note, comment, product, and review together, and a sourcing flow of "find keyword, read content, read comments, check product, read reviews" is one $0.005556 request per step, with a cost that is easy to estimate.

One more is the Pugongying content square (xiaohongshu/pgy_content_square). This capability is priced at $0.016 per request ($16 per 1,000), and on the day the call returned 503 and was not charged. We record it as observed: this tier was unavailable at the time and not billed. The 16 standard content capabilities all returned and charged that day. This tier was the most expensive in the catalog and the only one that returned no data at the time. Since November 18, 2026, this capability only searches by keyword, and keyword is required.

Failures, empty results, and rate limits: what is charged

This bears directly on the monthly bill, so we tested several "did not get data" cases. Our notes state that failed calls and empty results are not charged (EveryInfra llms.txt, read 17 November 2026). Here are the actual results.

CaseTime (SGT)HTTPResponseCharge
No key00:38:06401missing_key, told to put the key in the Authorization header$0
sort set to a non-existent value00:38:08422invalid_value, lists allowed values and catalog_url$0
A non-existent note link00:38:27200empty result, reason is empty_result_refunded$0
An extra limit parameter00:38:18200returns 15 rows as usual, limit ignored$0.005556

No key returns 401 and missing_key: authenticate first, and an unauthenticated request does not run for free. A bad enum returns 422 and invalid_value, and the error lists the allowed values directly, the legal values for sort being most_collected, most_commented, most_liked, newest, and relevance, with a catalog URL to self-check, none of which was charged. A non-existent note returns 200, an empty result, and reason of empty_result_refunded, refunded on the spot at $0. An extra limit parameter that does not affect the result returns normally and charges once, because this capability pages by default and ignores limit.

Rate limits are another billing-relevant point. The API has a per-minute ceiling, and firing too many in a short window returns 429. These rate-limited requests are not charged, and you retry after a short wait. We hit a 429 once in this round (returning rate_limited), paused 60 seconds, and continued, with no entry on the ledger. For a bulk job this means you need not worry that an occasional rate limit takes your money, as long as the client backs off and retries. The credit-based third-party also states that "requests rejected over the rate limit do not cost credits", so the two agree here. What ultimately moves the bill is always the requests that succeed in returning data. Rate limits and empty results do not enter it.

Read against the third-party side, one difference stands out. As noted above, one third-party says "some failed wallet-funded requests incur a processing charge at cost", so not every failure is free, while the credit-based one does not charge rejected over-limit requests. Our rule is that failures and empty results are both free, and parameter errors are caught before billing. For a long-running collection job, that rule means you do not pay for the platform's occasional empty results or your own mistyped parameters. The bill only counts data you actually got.

A monthly bill: five common jobs

Put the unit price into five common uses, counted over a month. Our side is request count times $0.005556. The third-party uses the cheapest public tier at $10 per 1,000. The official open platform, which does not retail content data per call and needs qualification and authorization, is not in this money table. Open-source, free as code but with its own servers and proxies, is hard to compare per request, so the table compares only the pay-per-call API and us.

Monthly jobRequestsThird-party lowest publicEveryInfra (measured)
100 keywords, 1 page each daily3,000$30.00$16.67
500 brand notes, 2 comment pages each1,000$10.00$5.56
200 creators, profile + 1 content page daily12,000$120.00$66.70
2,000 products, detail + 1 review page each4,000$40.00$22.20
Dumbbell chart, horizontal axis monthly US dollars on a log scale. Four rows, each with a teal dot for EveryInfra on the left and a grey dot for the third-party lowest public price on the right: 100 keywords 1 page daily $16.67 vs $30; 500 notes 2 comment pages $5.56 vs $10; 200 creators profile plus content $66.70 vs $120; 2000 products detail plus reviews $22.20 vs $40. Note: most third-party plans also add a minimum or monthly fee, not counted.

Take the first row apart to show why per-request billing helps. 100 keywords, 1 page each per day, is 100 times 30, which is 3,000 requests a month, each at $0.005556, totalling $16.67. At 20 rows each that is 60,000 notes a month, about $0.278 per 1,000. If some keywords have no new content and return empty on a day, those calls are free and the bill is lower. To go deeper, page hot keywords a few more times: paging a keyword 3 times a day is 3 calls a day, 90 a month, so the whole batch of 100 is 9,000 calls a month at $50.00, still below the third-party cheapest tier on the same basis. Per-request budgets are therefore easy to estimate: count "calls per day times days" and multiply by $0.005556 for an upper bound, with the actual lower because of empty results.

The multiples hold near 1.8 because both sides bill per request and the difference is the unit price. Two reminders, though. First, most third-party plans also add a minimum top-up or monthly fee, not counted above. On real bills, a monthly fee lifts the unit price when volume is low, widening the gap beyond 1.8. Second, our balance does not expire and failures are free, so the actual charge is often below the budget, for example the 200-creator row drops below $66.70 if some accounts are closed or empty. To try these numbers yourself, run a few calls with a test key from the marketplace. The response's charged_usd writes out every actual charge.

When not to use a pay-per-call API

To be complete: there are cases where a pay-per-call API is not the best answer. First, if you are a researcher or student with small volume who can patch code anytime, open-source is near zero cost and cheapest to run yourself. Second, if you are a Xiaohongshu merchant and want your own store's orders, inventory, and business data, the official open platform is the right channel, giving you merchant-authorized data with downstream transaction capability that no third-party collection can. Third, if you want every comment on a hot note and every reply, run in one go, a scheme that deep-pages automatically and bills per row is stronger on convenience. We do one page at a time and ask you to pass the page_token.

Another case to state honestly: a pay-per-call API does not guarantee data the platform restricts. Login-gated content, more tightly protected endpoints, and results that only return in specific regions may be incomplete on any third-party route. Our side collects only publicly visible data, returns an empty result with a refund when something is out of reach, and does not pretend to have it. Weigh "what you can get" alongside "the price per 1,000", and choose by the fields and depth your work needs. Per-request billing helps here, since a small test batch confirms coverage and fields before you scale, at low cost.

Xiaohongshu itself is worth a line on why it is a high-value data source. The platform announced more than 400 million monthly active users and over 800 million daily searches in May 2026 (Sina Finance, 27 May 2026), with a user base skewed to young, high-tier-city users (Investing.com, Gelonghui). Its commercial ecosystem is mature too: Pugongying brand invitations reached 27 million in 2025, up 34% year on year, with a 10% platform service fee on brand orders (Huxiu, Xiaohongshu passes 400 million MAU, 29 May 2026). For teams doing brand sentiment, sourcing, or creator selection, Xiaohongshu's public notes and comments are unavoidable source material, which is exactly why these three data routes exist.

Industry notes: what happened recently

  • In May 2026, Xiaohongshu announced more than 400 million monthly active users and over 800 million daily searches, took 2026 World Cup broadcast rights, and bet on medium-length video (Huxiu, 29 May 2026). What this means for data: content forms expand from images to video, podcasts, and long text, and video-related fields in notes carry more weight.
  • In 2026, research firms put Xiaohongshu's 2025 commercial revenue around 42 to 52 billion yuan, with advertising about 76% (Xueqiu, Xiaohongshu data; daxue consulting, 2026). What this means for data: the more commercial the platform, the stronger the demand for public sentiment and competitor data.
  • In January 2025, many "TikTok refugees" moved to Xiaohongshu, pushing it briefly to the top of the US App Store free chart (Reuters, 15 January 2025; BBC, 14 January 2025). What this means for data: the platform's overseas profile rose, and so did interest in its data from teams abroad.
  • Through late 2026, developer-community discussion of Xiaohongshu collection still centres on signing (x-s, x-t) breaking with app updates and needing upkeep (Juejin, 2026). What this means for data: the upkeep cost of self-built collection has not fallen, which is precisely the value of a pay-per-call API.

Questions

How much does the Xiaohongshu API cost?

Three routes. The official open platform does not retail note or comment content per call. It runs an enterprise-qualification, review, and QPS-based merchant channel. Open-source code is free but you supply servers, proxies, and upkeep. Pay-per-call third-party APIs list $10 to $38 per 1,000 requests. We measured EveryInfra at $0.005556 per request, $5.556 per 1,000 (live calls on 17 November 2026).

Does Xiaohongshu have an official data API?

There is an open platform, but it serves merchants and service providers, mainly commerce, advertising, and creator marketing, and merchant data needs authorization, an enterprise qualification, per-capability approval, and a review cycle (CNDev, read 17 November 2026). It is not a shelf for buying public notes and comments per call. For public content, most teams use open-source scripts or a pay-per-call API.

How do I get Xiaohongshu data with Python?

Two common ways. One is an open-source library such as pip install xhs (xhs on PyPI) or running MediaCrawler, handling the login session, proxies, and signing yourself. The other is calling a pay-per-call HTTP API, where a single POST with requests suffices and you maintain no signing. The quickstart below gives the shortest EveryInfra example.

Will a Xiaohongshu crawler get banned, and is it legal?

Self-built crawling carries its own risk and compliance burden. The open-source projects state "study only, commercial use prohibited" and warn that web crawling may be illegal (MediaCrawler; ReaJason/xhs). Processing personal information must follow the Personal Information Protection Law (NPC). A pay-per-call API outsources the collection step, but compliant use remains the user's responsibility.

What does 1,000 comments cost?

By our measurement, comments return 15 rows per request at $0.005556, about $0.370 per 1,000. De-duplicated by page_token it is about $0.411. Pay-per-call third-party APIs bill $10 to $38 per 1,000 requests and also return one page each, so per 1,000 rows is likewise about twice ours and up. This comes from converting the measured return for the query "how much does the Xiaohongshu API cost".

Getting started: three steps to a real call

First, get a key, from the marketplace or the quickstart. Second, read the free catalog to confirm capability names, parameters, and the unit price:

bash
curl -s "https://api.everyinfra.com/api/v1/social/catalog?platform=xiaohongshu"
# read each capability's action, required_params, price_usd, response_fields, available

Third, make a real request. Here is this article's search call, returning 20 notes and charging $0.005556:

bash
curl -s https://api.everyinfra.com/api/v1/social \
  -H "Authorization: Bearer $EVERYINFRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"platform":"xiaohongshu","action":"search","params":{"keyword":"skincare"}}'
# response has count=20, billing.charged_usd=0.005556, billing.amount.per_1k.USD=5.555556
# paging: put the response's next_page_token into params.page_token and request again

For comments, change action to comments and give url in params. For a profile use profile with user_id. For reviews use reviews with product_id. Each capability's fields and parameters are in the catalog. In AI tools, EveryInfra is also a remote MCP service (MCP is the protocol by which AI clients call external tools. See the specification 2025-06-18 and the client list), with tool names starting everyinfra_, so a model can call it with a short config. Per-capability pages have field-by-field detail: search, comments, note detail, the platform overview at Xiaohongshu data API, and Douyin's equivalents at Douyin data API. For a deeper comparison, read official open platform vs third-party collection and three ways to collect Xiaohongshu data.

References

  1. Xiaohongshu open platform, https://open.xiaohongshu.com/ (read 2026-11-17)
  2. Xiaohongshu School, open-platform request signing, https://school.xiaohongshu.com/en/open/quick-start/sign.html (read 2026-11-17)
  3. CNDev, Xiaohongshu open platform ecosystem API access, https://cndev.cn/platform/xiaohongshu-open/ (read 2026-11-17)
  4. Tencent Cloud developer community, Xiaohongshu open-platform API in practice, https://developer.cloud.tencent.com/article/2735161 (2026-08-31)
  5. Alibaba Cloud developer community, Xiaohongshu note-detail API for competitor analysis, https://developer.aliyun.com/article/1705081 (2026-01-09)
  6. CRMEB, Xiaohongshu note-detail API explained (official vs third-party collection), https://www.crmeb.com/ask/thread/75859 (2026-06-17)
  7. MediaCrawler (GitHub, NanmiCoder), https://github.com/NanmiCoder/MediaCrawler (read 2026-11-17)
  8. MediaCrawler readme and disclaimer, https://github.com/NanmiCoder/MediaCrawler#readme (read 2026-11-17)
  9. MediaCrawler issues (GitHub), https://github.com/NanmiCoder/MediaCrawler/issues (read 2026-11-17)
  10. ReaJason/xhs (GitHub), https://github.com/ReaJason/xhs (read 2026-11-17)
  11. xhs (PyPI), https://pypi.org/project/xhs/ (read 2026-11-17)
  12. Juejin, MediaCrawler: a 42.6k-star cross-platform crawler, https://juejin.cn/post/7595142737513873435 (2026)
  13. Juejin, MediaCrawler uses CDP mode to bypass JS reverse-engineering, https://juejin.cn/post/7667386123949817902 (2026)
  14. Third-party RedNote data API, pricing page, https://getanyapi.com/api/rednote (read 2026-11-17)
  15. Third-party RedNote data API, docs, https://getanyapi.com/docs (read 2026-11-17)
  16. Third-party RedNote data API, pricing and notes, https://rnote.dev/en/ (read 2026-11-17)
  17. Third-party RedNote data API, docs, https://rnote.dev/en/docs/guide (read 2026-11-17)
  18. Third-party Xiaohongshu/RedNote API, docs, https://docs.justoneapi.com/en/api/xiaohongshu-rednote/ (read 2026-11-17)
  19. Third-party Xiaohongshu scraper API, endpoints and pricing, https://www.socialcrawl.dev/platforms/xiaohongshu (read 2026-11-17)
  20. EveryInfra, data API catalog, https://api.everyinfra.com/api/v1/social/catalog (read 2026-11-17)
  21. EveryInfra, llms.txt (failures and empty results not charged), https://api.everyinfra.com/llms.txt (read 2026-11-17)
  22. EveryInfra, data API endpoint, https://api.everyinfra.com/api/v1/social (read 2026-11-17)
  23. EveryInfra, remote MCP endpoint, https://api.everyinfra.com/mcp (read 2026-11-17)
  24. Model Context Protocol, specification 2025-06-18, https://modelcontextprotocol.io/specification/2025-06-18 (read 2026-11-17)
  25. Model Context Protocol, client list, https://modelcontextprotocol.io/clients (read 2026-11-17)
  26. Python documentation, urllib.request, https://docs.python.org/3/library/urllib.request.html (read 2026-11-17)
  27. requests documentation, https://requests.readthedocs.io/en/latest/ (read 2026-11-17)
  28. requests (PyPI), https://pypi.org/project/requests/ (read 2026-11-17)
  29. NPC, Personal Information Protection Law, http://www.npc.gov.cn/npc/c2/c30834/202108/t20210820_313088.html (2021-08-20)
  30. NPC, Data Security Law, http://www.npc.gov.cn/npc/c2/c30834/202106/t20210610_311888.html (2021-06-10)
  31. NPC, Cybersecurity Law, http://www.npc.gov.cn/npc/zgcpfyfx/201611/t20161107_396272.html (2016-11-07)
  32. Cyberspace Administration of China, Network Data Security Management Regulations, http://www.cac.gov.cn/2024-09/30/c_1730513931362305.htm (2024-09-30)
  33. MIIT, ICP/IP/domain filing system, https://beian.miit.gov.cn/ (read 2026-11-17)
  34. hiQ Labs, Inc. v. LinkedIn Corp. (court record), https://www.courtlistener.com/docket/4315666/hiq-labs-inc-v-linkedin-corporation/ (read 2026-11-17)
  35. Reuters, Over half a million TikTok refugees flock to China's RedNote, https://www.reuters.com/technology/over-half-million-tiktok-refugees-flock-chinas-rednote-2025-01-14/ (2025-01-15)
  36. BBC, TikTok users flock to Chinese app RedNote as US ban looms, https://www.bbc.com/news/articles/c2475l7zpqyo (2025-01-14)
  37. Business Insider, RedNote and Lemon8 surge as TikTok ban looms, https://www.businessinsider.com/rednote-lemon8-surge-as-tiktok-ban-looms-chinese-social-apps-2025-1 (2025-01-13)
  38. Huxiu, Xiaohongshu passes 400 million MAU, https://www.huxiu.com/article/4861801.html (2026-05-29)
  39. Sina Finance, Xiaohongshu passes 400 million MAU and 800 million daily searches, https://finance.sina.com.cn/jjxw/2026-05-27/doc-inhziqxq9291575.shtml (2026-05-27)
  40. daxue consulting, Xiaohongshu (RedNote) in China 2026, https://daxueconsulting.com/xiaohongshu-rednote-china (2026)
  41. Xueqiu, record of Xiaohongshu commercial revenue and ad structure, https://xueqiu.com/2663709332/396773177 (2026)
  42. Investing.com, Gelonghui, the wishes and worries of Xiaohongshu, https://cn.investing.com/analysis/article-200490381 (2025)

Reference BL-177

Google Analytics needs consent. Privacy