> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.beatapi.io/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.beatapi.io/_mcp/server.

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

> Choose traffic scope for a collaboration review, distinguish sponsored content from paid traffic, and compare matching notes before interpreting results.

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?

| Question                                                  | Selection 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:

```bash
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 input    | Options                        |
| ------------------ | ------------------------------ |
| `business`         | 0 everyday, 1 cooperation      |
| `advertise_switch` | 0 organic, 1 all traffic       |
| `date_type`        | 1 last 30 days, 2 last 90 days |
| `note_type`        | 1 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](/faq/xiaohongshu-audience-quality) 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](https://beatapi.io/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:

```json
[{"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.

```python
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.