Перейти к навигации

How should I use organic and all-traffic reading when choosing Xiaohongshu creators?

To see organic reads on a Xiaohongshu creator’s notes, set advertise_switch to 0 in the Pugongying core-data query xiaohongshu.pgy.get_blogger_core_data or in the note case query xiaohongshu.pgy.get_blogger_notes. Set advertise_switch to 1 for all traffic, including promotion. Choose the content format and the everyday or cooperation scope with separate inputs.

For example, to compare three coffee tutorial creators, use the same format, observation window and traffic scope for all three. To compare organic and all-traffic reads on one note, match the two results by noteId and record when each result was collected.

Which data answers your question?

QuestionSelection and use
How has recent everyday or cooperation content performed?Use core data with a consistent period, format and traffic scope
Which tutorials make useful collaboration references?Review note cases under organic scope and read the content
What reading does the same note report under each scope?Save both case pages, match note IDs and compare
What did this project’s promotion achieve?Add the project’s own delivery and closing reports with aligned definitions

The cooperation category describes a note’s content: a cooperation note did not necessarily receive paid traffic, and an everyday note is not necessarily free of promotion. Select the traffic scope with advertise_switch separately from the category.

Start with consistent core metrics

The request below asks xiaohongshu.pgy.get_blogger_core_data for the creator’s last 30 days, image-text plus video, cooperation notes and organic traffic, which gives one period observation for candidate review:

curl -sS https://api.beatapi.io/v1/social-data/call \
-H "Authorization: Bearer $BEATAPI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{"action":"xiaohongshu.pgy.get_blogger_core_data","params":{"user_id":"<user_id>","business":1,"advertise_switch":0,"date_type":1,"note_type":3}}' \
-o creator-organic-cooperation.json
Core-data inputOptions
business0 everyday, 1 cooperation
advertise_switch0 organic, 1 all traffic
date_type1 last 30 days, 2 last 90 days
note_type1 image-text, 2 video, 3 both

For individual cases, xiaohongshu.pgy.get_blogger_notes uses note_type 4 for all, 3 for cooperation, 1 for image-text and 2 for video. Use each action’s own values: core-data value 3 (both formats) means cooperation in the case list.

How do you use the two reading counts?

Match the same noteId, keep both observation times, then compare readNum. In an illustrative example, organic reads of 1,000 and all-traffic reads of 1,600 give an observed difference of 600. Record the difference with both sources and investigate the difference together with the project’s own information.

If the all-traffic page lacks the note, mark the note unmatched instead of filling zero. Sorting by reads can select different notes under each scope, so to compare the same content, use newest order with all other inputs unchanged and keep the unmatched notes.

For creator selection, read the relevant tutorials and combine comparable organic counts with audience information to explain each candidate choice. For closing reports, keep observed differences separate from project attribution. The two queries run at different times, and aggregate medians or ratios are not per-note counts that you can subtract.

To hand the task to an assistant with the tools configured, use a prompt such as:

Review these three coffee-tutorial creators for collaboration. Keep period, format and traffic scope consistent. Start with relevant tutorials’ organic reading and content. Where both saved scopes exist, pair note IDs, retain times and unmatched notes, and identify useful content and candidate reasons.

The local comparator compare_pgy_scopes.py below converts two saved case pages into a source-linked note table.

Compare two saved note pages without inventing paid attribution

For a note-level comparison, use xiaohongshu.pgy.get_blogger_notes, not a creator aggregate. The documented return description establishes data.data.list[].noteId and readNum. Request the same creator, note type, page and page size with newest order (order_type: 1), and change only advertise_switch. Pages ranked by reads can contain different notes under the two scopes, so a reads-ranked page is not a matched sample. Even newest-order pages can shift between calls, so join by actual note IDs and keep unmatched notes.

Prices are on the current pricing page. One case page for each scope is two page requests; reuse saved originals when you have them. Save the actual responses and fill the manifest below with the real collection times:

[{"action":"xiaohongshu.pgy.get_blogger_notes","params":{"user_id":"YOUR_VERIFIED_USER_ID","note_type":3,"order_type":1,"advertise_switch":0,"page_number":1,"page_size":8},"collected_at":"2026-11-16T10:00:00Z","response_file":"organic.json"},{"action":"xiaohongshu.pgy.get_blogger_notes","params":{"user_id":"YOUR_VERIFIED_USER_ID","note_type":3,"order_type":1,"advertise_switch":1,"page_number":1,"page_size":8},"collected_at":"2026-11-16T10:01:00Z","response_file":"all.json"}]

Save the script below as compare_pgy_scopes.py. The script validates saved successful business results, rejects changed filters and duplicate note IDs within a page, and writes the union of note IDs with matched and missing coverage. compare_pgy_scopes.py makes no calls.

import csv,datetime,hashlib,json,pathlib,sys
manifest,target=map(pathlib.Path,sys.argv[1:3])
entries=json.loads(manifest.read_text(encoding="utf-8"))
if not isinstance(entries,list) or len(entries)!=2:raise ValueError("Exactly one organic and one all-traffic saved request required")
scopes={};base=None;request_ids=set()
for entry in entries:
if entry.get("action")!="xiaohongshu.pgy.get_blogger_notes":raise ValueError("Use note cases, not aggregate metrics")
params=entry["params"]
allowed={"user_id","note_type","order_type","advertise_switch","page_number","page_size","feature_tag","content_tag","is_third_platform"}
if not isinstance(params,dict) or set(params)-allowed:raise ValueError("Use only documented input fields")
for tag in ("feature_tag","content_tag"):
if tag in params and (not isinstance(params[tag],str) or len(params[tag])>64):raise ValueError("Invalid tag filter")
if "is_third_platform" in params and (type(params["is_third_platform"]) is not int or params["is_third_platform"] not in (0,1)):raise ValueError("Invalid cross-platform filter")
scope=params.get("advertise_switch")
if type(scope) is not int or scope not in (0,1) or scope in scopes:raise ValueError("Need distinct scopes 0 and 1")
if not isinstance(params.get("user_id"),str) or not params["user_id"].strip():raise ValueError("Record user_id")
if params.get("order_type")!=1 or type(params.get("order_type")) is not int:raise ValueError("Use newest order, not scope-dependent reading rank")
for key in ("page_number","page_size","note_type"):
if type(params.get(key)) is not int:raise ValueError("Record explicit note/page settings")
if not 1<=params["page_number"]<=1000 or not 1<=params["page_size"]<=8 or params["note_type"] not in (1,2,3,4):raise ValueError("Invalid note/page settings")
other={key:value for key,value in params.items() if key!="advertise_switch"}
if base is None:base=other
if base!=other:raise ValueError("Only traffic scope may differ")
stamp=entry["collected_at"];dt=datetime.datetime.fromisoformat(stamp.replace("Z","+00:00"))
if dt.tzinfo is None:raise ValueError("Timezone required")
path=pathlib.Path(entry["response_file"])
if not path.is_absolute():path=manifest.parent/path
raw=path.read_bytes();digest=hashlib.sha256(raw).hexdigest()
r=json.loads(raw)
if r.get("error") is not None or r.get("status")!="succeeded" or r.get("action")!=entry["action"]:raise ValueError("Failed or wrong response")
rid=r.get("request_id")
if not isinstance(rid,str) or not rid.strip() or rid in request_ids:raise ValueError("Distinct request IDs required")
request_ids.add(rid)
envelope=r.get("data")
if not isinstance(envelope,dict) or envelope.get("success") is not True:raise ValueError("PGY business failure")
data=envelope.get("data")
if not isinstance(data,dict) or not isinstance(data.get("list"),list):raise ValueError("Expected non-null note list")
notes={}
for item in data["list"]:
if not isinstance(item,dict):raise ValueError("Bad note object")
note=item.get("noteId")
if not isinstance(note,str) or not note.strip() or note in notes:raise ValueError("Distinct real noteId required per page")
value=item.get("readNum")
if type(value) is int and value>2**53-1:raise ValueError("Unsafe JSON count; preserve an original digit string instead")
if isinstance(value,str) and value.isascii() and value.isdigit():value=int(value)
if value is not None and (type(value) is not int or value<0):raise ValueError("readNum must be integer/digit string or missing")
notes[note]=value
scopes[scope]={"notes":notes,"request_id":rid,"collected_at":stamp,"source_file":str(path.resolve()),"sha256":digest}
rows=[]
for note in sorted(set(scopes[0]["notes"])|set(scopes[1]["notes"])):
organic=scopes[0]["notes"].get(note);all_reads=scopes[1]["notes"].get(note)
present0=note in scopes[0]["notes"];present1=note in scopes[1]["notes"]
state="both" if present0 and present1 else ("organic_only" if present0 else "all_only")
delta=all_reads-organic if organic is not None and all_reads is not None else None
rows.append({"noteId":note,"coverage":state,"organic_reads":organic,"all_reads":all_reads,"observed_difference":delta,
"review":"missing_metric" if state=="both" and delta is None else ("negative_difference" if delta is not None and delta<0 else ""),
"organic_request_id":scopes[0]["request_id"],"all_request_id":scopes[1]["request_id"],
"organic_collected_at":scopes[0]["collected_at"],"all_collected_at":scopes[1]["collected_at"],
"organic_source_sha256":scopes[0]["sha256"],"all_source_sha256":scopes[1]["sha256"]})
def cell(value):
if value is None:return ""
if isinstance(value,int):return value
return "'"+value if value.lstrip().startswith(("=","+","-","@")) or value.startswith(("\t","\r","\n")) else value
with target.open("x",encoding="utf-8-sig",newline="") as output:
writer=csv.DictWriter(output,fieldnames=["noteId","coverage","organic_reads","all_reads","observed_difference","review","organic_request_id","all_request_id","organic_collected_at","all_collected_at","organic_source_sha256","all_source_sha256"])
writer.writeheader();writer.writerows({key:cell(value) for key,value in row.items()} for row in rows)
print(str(target))

Run python3 compare_pgy_scopes.py scope-manifest.json scope-comparison.csv. Keep both original files and the manifest next to the CSV. observed_difference is arithmetic on two observations, not verified paid-attributed reads. Missing values stay blank; negative differences are kept and flagged for review, not clamped to zero. Check times, coverage and definitions before interpreting any value. Sources: the test fixture is synthetic, so the fixture does not show that two real counts differ only by paid traffic.

For creator trends, xiaohongshu.pgy.get_blogger_core_data documents data.data.dailyData and data.data.sumData but does not specify every inner daily CPM or date key. Do not feed the core-data aggregates into compare_pgy_scopes.py, and do not subtract medians or ratios to invent paid-reader counts.

Review the comparison before choosing creators

Open the CSV in this order: coverage, review, observation times, then read counts. organic_only and all_only mean the note appeared on only one of the two pages, not that the other scope had zero traffic. missing_metric means you check the saved response; negative_difference is a review flag, not negative paid delivery. Two empty successful pages show only that the two selected pages were empty, not that the creator has no historical notes.

For a shortlist, use matched organic reads as one observed content signal, keep unmatched candidates for review, and carry the note IDs and observation times into your assessment. Do not rank creators by a ratio computed from different note sets. The comparison covers one page per scope, not a full account audit. For additional pages, approve the cost separately and use the same selection rules.

Each row includes the SHA-256 of both original response files. Keep those exact bytes with scope-manifest.json and the CSV. The hashes bind each row to the local source bytes; the hashes do not authenticate the server or the manually recorded collection time. Unsafe large JSON numbers, invalid counts, unsupported filters and mismatched scopes stop the export before the CSV is created. Counts that arrive as digit strings keep their full precision.