# Chinese Social Media Dataset Translator to English (`zinin/chinese-social-media-dataset-translator`) Actor

Translate supplied Chinese social media datasets to English while preserving hashtags, mentions and emoji. Export pinyin and script variants with row status.

- **URL**: https://apify.com/zinin/chinese-social-media-dataset-translator.md
- **Developed by:** [Tim Zinin](https://apify.com/zinin) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 1,000 translated rows

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Chinese Social Media Dataset Translator to English

Translate supplied Chinese social-media exports while preserving source fields, protected text and per-row completion status.

**Evidence status: private build 0.1.8 accepted on 2026-09-06.** Every input/output example below is an exact dataset row or OUTPUT record from the accepted private acceptance runs on Apify's network with the pay-per-event tariff active. The listing is not public yet; no scheduled task or review history is claimed.

![Buyer input to reviewed result](assets/readme-hero.webp)

### What you get

The Chinese Social Media Dataset Translator processes an export already supplied by the buyer. It translates selected text fields, preserves original columns, protects URLs, hashtags, mentions and emoji sequences, and optionally adds local pinyin and script conversion. It creates one Translated row only when every selected field and protected span passes validation. A batch with two complete rows and one damaged row keeps the two useful rows paid and the damaged row free.

No account login, platform scraping or page collection is included. A source object may come from a lawful purchased export, the buyer's own records or another authorized collection process. That provenance does not cause the Actor to revisit a source URL. The only model network operation is the compatible chat request; pinyin and simplified/traditional conversion run locally.

### Who uses it

Cross-border research teams use it to make a supplied Chinese-text export readable for colleagues. Customer-experience teams use it to prepare review candidates from their own authorized feedback tables. Localization teams use pinyin and script views beside a translation for language review. Analysts can retain source IDs, timestamps and engagement columns while adding a distinct translated namespace rather than flattening everything into an untraceable English paragraph.

Use it when the source text already exists and its fields can be named explicitly. It is not a sentiment classifier, a social listening collector or an author identity service, and a complete structure can still hold an awkward translation: review a representative sample with someone who knows the source context.

#### Field preservation and selected paths

`fields` names up to twenty literal dotted paths. Every selected value must be a string. A row with a missing or nonstring selected field becomes a free error; a row whose selected strings are all blank is correct not-found without an LLM call. If a row contains both blank and nonblank selected fields, the nonblank fields are translated while the empty ones must remain exactly empty. Duplicate selectors are rejected before a paid request.

The output `translated` object uses the exact selected path strings as keys. Selecting `post.caption` produces `translated["post.caption"]`, not a newly expanded `translated.post.caption` object. The original nested `post` object remains in the source payload. This makes the mapping deterministic and avoids guessing an output nesting scheme for a buyer's arbitrary source columns.

Names reserved by the Actor cannot overwrite processing status. If the input already contains `translated`, `status`, `rowId`, `tokens` or another reserved name, its original value is moved under `original`. Ordinary original columns remain at the top level. Secret-named properties are removed recursively and known credential echoes are scrubbed; this does not mean every original personal field is anonymized. Retain only data you have a reason and permission to process.

#### Protection, glossary and script views

Before translation, recognized URLs, hashtags, @mentions, emoji sequences and glossary terms are replaced with deterministic markers. The response must preserve each marker exactly once. Restoration returns protected spans to their original text, or to the explicitly mapped glossary value. Missing, duplicated or unknown markers invalidate that row. Full neighboring rows remain usable. The translator does not silently accept a missing hashtag as a successful translation.

Glossary entries map a source term to a desired output string. At most 100 nonempty pairs of at most 100 characters each are accepted. Longest overlapping glossary terms win, so a longer technical name can be distinguished from its shorter component. URLs and social tokens are protected as whole spans. Choose glossary terms deliberately, review overlap on a small sample and do not use a glossary as an executable replacement program.

Pinyin uses the locally pinned pinyin-pro package on original selected strings. Script conversion uses opencc-js: traditional converts from simplified Chinese toward the configured Taiwan form; simplified converts back toward simplified Chinese. These are views of the original text, not model translations of the English answer. With `scriptMode:none`, no script conversion is requested. Pinyin and orthographic conversion can require contextual review for names, polyphonic characters and regional terminology.

Language detection uses character-presence heuristics: Chinese characters, Latin letters, both, or undetermined. `sourceLanguage` is null when detection is off. Dialect markers are a small observed dictionary such as 咩, 唔, 嘅, 侬 and 啥 with `provenance:heuristic` and null confidence. They are not proof of an author's dialect, residence or identity. Avoid building audience segmentation from these markers alone.

#### Batching and allocated cost

`batchSize` is at most 10. Before every request the Actor shrinks the batch to fit the remaining result budget, row cap and input-unit allowance. Five complete translations are still five atomic result pushes. A batch is not a single billable unit. Responses are joined by their supplied `rowId` strings, so provider reordering does not corrupt the source join. Missing or duplicate IDs make the affected row incomplete; unexpected IDs make the batch response unsuitable for a trusted join.

Provider tokens and cost are measured per batch; per-row values are estimates allocated by the UTF-8 byte weight of the prepared fields, and integer allocation plus a final remainder preserves the batch totals. `costAllocation` and `tokens.allocation` name the estimate. Preserve `batchId` and the run ID when auditing sums.

`requested` and `processed` refer to source rows. The keyless cap permits at most twenty rows even when ten rows share one model call. The default is five synthetic rows with `demo:true`; every output from that designated demo, including free notices, retains the flag, and `OUTPUT.demoInput` is true. Supplying a Dataset ID bypasses demo prefill.

### Commercial playbooks

#### Export-to-brief for an international team

Select the source text fields and retain source IDs and dates as original columns. Use a glossary for product names and internal terminology. Translate a representative sample, have a bilingual reviewer assess it, then process the approved remainder. Deliver the original Chinese, English candidate and status side by side. Keep partial rows in a review queue so a missing selected caption cannot be mistaken for an intentionally empty post.

#### Customer-feedback triage preparation

Use an authorized feedback export with a clearly defined purpose and limited personal data. Translate only the text required by the triage team, leaving operational IDs available for joins. Route complete rows into an internal review tool and failed rows to source correction. Do not automatically publish a reply or infer sentiment from the translation alone. The commercial output is a readable, traceable working table, with a separate human decision about customer action.

#### Localization terminology review

Prepare a glossary containing the approved spellings and run a small sample with hashtags, mentions, emoji and overlapping terms. Compare translated text with the local pinyin or script view where useful. If protected-span validation fails, inspect that row rather than accepting a lossy result. Build a reviewed glossary revision outside the Actor and retain its version in the buyer's job record before the next batch.

### 中文说明

中文社交媒体数据集翻译器只处理买家提供的导出数据，不访问抖音、小红书、微博等页面。选择 `fields:["text"]`，保留原字段并增加 `translated`、拼音及简繁转换结果。话题标签、@提及、链接和表情通过占位符保护；损坏行免费，完整邻行可正常交付。默认五行是合成演示，每行有 `demo:true`，摘要含 `demoInput:true`。实际业务需确认数据使用权限并审阅翻译；演示不能替代真实导出数据的验收。

![Automation workflow and downstream review](assets/readme-workflow.webp)

### How to run

Begin with the small prefill and inspect both the Dataset and the `OUTPUT` record. The input form contains examples, but an example is not a credential or a promise that a provider account has access to a model. Keep `maxConcurrency` at 1. The default runtime allocation is 512 MiB with a 300-second timeout; the Actor stops admitting ordinary work after a 240-second deadline. A smaller workload is the right first check when changing a prompt, field selection, provider or language.

Omit `apiKey` to use the platform OpenRouter credential within the keyless limits, or enter a buyer credential in the secret input field with a compatible allowed endpoint and model. A nonempty buyer key is authoritative for that run; an authentication failure never silently switches the call to the platform account.

Start a run, wait for its final status, and inspect `OUTPUT.fatal` before downstream processing. Filter Dataset results using `found === true`, `partial === false`, `resultCount === 1` and `error === ""`. Keep free notices in a separate operational table. A successful process exit alone is insufficient to establish that every requested unit was completed. `unprocessed`, `failed`, `partial` and the Actor-specific counters explain what happened to the rest.

### Pricing

The pricing is **$0.005 per automatic run start plus $0.004 per Translated row**, set on the platform tariff and read back from the accepted run receipts below. The result event is `result-found`. One complete Translated row causes one atomic SDK push with that event; the Actor never manually charges a start event.

The word “free” on this page refers to the result event. Errors, missing results, partial rows and operational summaries do not carry `result-found`, but the automatic start can already have been charged. A run with no complete result is therefore not necessarily a zero-dollar run. The planned arithmetic for 0, 1 and 2 complete results is $0.005, $0.009 and $0.013. These figures describe Actor event pricing; they do not include an independent invoice from a provider used with BYOK.

BYOK means the buyer supplies the LLM credential and pays that provider under their own account terms, in addition to Actor charges for complete results. Dataset `costUsd` describes upstream model cost, not the Actor event price. A provider-reported cost is distinguished from a tariff estimate. Unknown model pricing is left null when no usable cost was returned. Never add `costUsd` to Actor revenue or treat a model usage estimate as proof that an Apify event was charged.

Before expensive work the Actor checks how many results the buyer budget can cover, and before each paid push it reads the tariff and the remaining money again inside the serialized delivery section, in conservative microdollars. The final charged row remains delivered even if the SDK signals that the spending limit is now reached; the next unit is not admitted.

On the platform, missing or unreadable pricing, an unreadable balance, a non-PPE tariff or a paid automatic Dataset-item event fails the run without writing explanatory Dataset records: the explanation lives in the log and the failed status. An uncertain write or charge also stops processing, and `deliveryUncertain` requires reconciliation before a retry.

The platform credential has separate upstream admission limits: $0.03 per run, at most 20 completed result units, 20 logical LLM jobs and 40 HTTP attempts. These are ceilings; input size, the token reserve, retries, the work deadline or the buyer budget can stop a run earlier. BYOK removes the platform subsidy limits but retains the Actor's bounded input, token and work controls. Raising an input value above a hard cap is rejected instead of silently weakening the protection.

At the pinned DeepSeek Flash output rate of $0.18 per million tokens, the 768-token default reserves $0.00013824 for output alone (about $0.00014). Input, retries and any provider-reported excess are accounted for separately. The shared costEstimate uses the configured maxOutputTokens for every attempt; reasoning usage is not charged twice.

The cost admission estimate uses the dated tariff evidence recorded on 2026-09-06 for the two allowed flash models. Search additionally reserves an allowance for web work. An admission estimate cannot certify a universal upper bound on an external provider invoice: reasoning, search injection and changed upstream rates can affect actual usage. Reported usage above the reserve stops further work. Provider account limits remain a separate operational control, and local mock costs do not prove production margin.

### Input contract

Inputs are JSON objects. Unknown top-level fields, invalid enum values, nonfinite numbers and wrong scalar types are rejected. Do not pass numeric strings where an integer is requested. The inline input is limited to 10 MiB of UTF-8 JSON. Opaque source rows have a 64 KiB limit, depth at most 8, at most 100 elements in each nested array and at most 200 properties in each object. These limits protect memory before prompt or batch expansion.

Where Dataset input is supported, reads use pages of at most 100 rows, with an aggregate limit of 5,000 rows and 10 MiB of retained row JSON. A working Dataset cap produces a partial summary with an omitted count rather than pretending the Dataset ended naturally. A failed Dataset read is an error, not an empty Dataset. The consumer is responsible for stabilizing the supplied Dataset during a run; pagination over a concurrently changing source is not a transactional snapshot.

Field selectors are literal dotted paths, up to 20 paths of 80 characters each. Duplicates are rejected. Property names such as `__proto__`, `constructor` and `prototype` are prohibited. Expressions, JavaScript functions and template evaluation are unsupported. Pass an already prepared field when a transformation needs arithmetic, complex filtering or application-specific access logic. This keeps the boundary between selecting data and executing code explicit.

The complete top-level form follows. `prefill` values are convenient small examples; defaults apply when a property is omitted. Conditional restrictions described here are also checked at runtime, including tighter platform limits than the maximum shown for BYOK. Secret fields intentionally have no example or prefilled credential.

#### `rows` — Supplied rows

Type: `array`. Default/sample: `see the complete form prefill; sample only`. Bounds: maxItems=500.

Inline buyer export, at most 500 objects. Prefill rows are explicitly synthetic demos. Dataset URLs and collection from social platforms are unsupported.

#### `datasetId` — Buyer dataset ID

Type: `string`. Default/sample: `"omitted"`. Bounds: maxLength=17.

Optional 17-character dataset ID read through your SDK permissions. Omit the inline items/rows property entirely when using this field. No dataset URLs. Pages <=100; total <=5000 rows and 10 MiB.

#### `fields` — Text fields to translate

Type: `array`. Default/sample: `["text"]`. Bounds: maxItems=20.

Every selected dotted path must be a string. One complete Translated row requires all selected fields and protected spans. No more than 20 paths.

#### `targetLanguage` — Target language

Type: `string`. Default/sample: `"en"`. Bounds: maxLength=20.

Language code or short label passed to the model, such as en, zh or de. Validate suitability with your selected provider on representative data.

#### `glossary` — Protected glossary

Type: `object`. Default/sample: `{}`. Bounds: maxProperties=100.

At most 100 source-to-output mappings, each key and value <=100 characters. Longest source terms win. Protected spans are restored to the mapped value.

#### `batchSize` — Rows per LLM call

Type: `integer`. Default/sample: `5`. Bounds: minimum=1, maximum=10.

At most 10. Batches shrink before requests to fit byte/token units and the number of rows the current buyer budget can cover.

#### `includePinyin` — Include source pinyin

Type: `boolean`. Default/sample: `true`.

Generate pinyin locally from the original Chinese text. Names, polyphonic characters and regional usage can need human review.

#### `scriptMode` — Source script conversion

Type: `string`. Default/sample: `"traditional"`. Bounds: values: none, traditional, simplified.

Convert original source strings to traditional or simplified Chinese using OpenCC, or choose none. These fields describe source text, not the translated answer.

#### `detectLanguage` — Include language heuristics

Type: `boolean`. Default/sample: `true`.

Use visible script to label zh, en, zh+en or und. Dialect markers are explicitly heuristic with null confidence; no identity or origin inference.

#### `maxItems` — Maximum processed source rows

Type: `integer`. Default/sample: `5`. Bounds: minimum=1, maximum=5000.

Count of source rows considered in this run, including free failures. Platform maximum 20; dataset ingestion independently caps at 5000 rows and 10 MiB.

#### `apiKey` — Buyer API key (optional)

Type: `string`. Secret; no example credential. Bounds: maxLength=512.

Optional buyer credential for the selected endpoint. Never copied to results. Empty uses the platform key only with OpenRouter. Buyer credentials are never replaced after a provider error.

#### `baseUrl` — OpenAI-compatible base URL

Type: `string`. Default/sample: `"https://openrouter.ai/api/v1"`. Bounds: maxLength=300.

HTTPS base path, without /chat/completions. Only documented host/path pairs are accepted. Custom native endpoints require apiKey. Search supports OpenRouter only. No query, credentials, fragments or redirects.

#### `model` — Model ID

Type: `string`. Default/sample: `"deepseek/deepseek-v4-flash"`. Bounds: maxLength=100.

Keyless: deepseek/deepseek-v4-flash or z-ai/glm-5.3-flash only. Qwen, Kimi and other model IDs require BYOK. The provider must support this model and operation.

#### `reasoningMode` — Thinking mode (OpenRouter)

Type: `string`. Default: `off`. Allowed values: `off`, `low`, `provider` (select editor).

Controls OpenRouter reasoning: off disables thinking where supported, low reduces effort, provider keeps provider defaults. Off uses low effort for z-ai/ models. Direct endpoints retain their own settings. See Thinking models and output tokens below for compatibility repeats and observed limits.

#### `maxOutputTokens` — Maximum completion tokens

Type: `integer`. Default/sample: `768`. Bounds: minimum=1, maximum=4096.

Upper completion allowance per call, including reasoning tokens. Platform hard maximum 1024; BYOK hard maximum 4096. Lower this for small tasks. Length-truncated answers are free incomplete results.

#### `maxTotalTokens` — Run token-unit limit

Type: `integer`. Default/sample: `40000`. Bounds: minimum=1, maximum=2000000.

UTF-8 message bytes plus completion reserve before each attempt, reconciled with valid usage afterward. Platform hard maximum 40000; BYOK 2000000. Unknown usage consumes full reserve.

#### `temperature` — Temperature

Type: `number`. Default/sample: `0.2`. Bounds: minimum=0, maximum=2.

Sampling temperature passed to the provider. Repeated runs can differ even at a low value. Does not establish factual correctness.

#### `maxConcurrency` — Concurrent LLM calls

Type: `integer`. Default/sample: `1`. Bounds: minimum=1, maximum=1.

Version 1 processes one call at a time. Billing and delivery are serialized. Schedule citation comparisons without overlapping runs.

#### Thinking models and output tokens

`maxOutputTokens` covers both visible output and provider reasoning tokens. OpenRouter receives `reasoningMode: "off"` by default as `reasoning: {"enabled": false}`. Models with the `z-ai/` prefix reject that setting, so `off` uses `{"effort": "low"}` for them. `low` always requests `{"effort": "low"}`; `provider` omits the parameter and keeps provider defaults. On OpenRouter only, an HTTP 400 in `off` mode allows one compatibility repeat with `effort: low`, then one without `reasoning` if the repeat also returns 400. A third 400 is returned as an error. These repeats count in `httpAttempts` and reserve tokens and COGS under the existing deadline and run caps; they do not consume the separate allowance of two network retries. At most five requests can result from one task when both allowances are used.

Live checks on 2026-09-06 (three prompts per setting, `max_tokens: 512`, platform credential): with provider defaults DeepSeek v4 Flash spent up to 3435 tokens on reasoning and GLM 5.3 Flash returned null content with `finish_reason: length` in 3/3 cases; with `off` DeepSeek finished 3/3 with 0 reasoning tokens in 3–4 s and GLM finished 3/3 under `effort: low`. These are acceptance observations, not a guarantee for every prompt.

Direct provider endpoints receive no `reasoning` parameter, regardless of this input, and retain their own thinking settings; `maxOutputTokens` must cover those settings. A null content with `finish_reason: length` remains `invalid_envelope`; truncated string content remains `incomplete_completion`. Both are free error rows. `reasoningTokens` reports the provider's nonnegative integer `usage.completion_tokens_details.reasoning_tokens`, or null when absent or invalid. It is already part of `tokensOut` (the translator's `tokens.output`) and is never added again for cost or token admission.

#### Endpoint and model selection

| Provider host | Accepted base path | Runtime requirement |
| --- | --- | --- |
| openrouter.ai | `/api/v1` | Platform key or buyer OpenRouter key |
| api.deepseek.com | empty path or `/v1` | Buyer key; provider-native model ID |
| api.moonshot.cn | `/v1` | Buyer key; provider-native model ID |
| open.bigmodel.cn | `/api/paas/v4` | Buyer key and compatible chat model |
| dashscope.aliyuncs.com | `/compatible-mode/v1` | Buyer key and compatible chat model |
| dashscope-intl.aliyuncs.com | `/compatible-mode/v1` | Buyer key for the selected region |
| ark.cn-beijing.volces.com | `/api/v3` | Buyer key and supported deployment ID |
| api.minimax.io | `/v1` | Buyer key and compatible model |
| api.minimaxi.com | `/v1` | Buyer key and compatible model |

The table is the transport allowlist, not a live certification of every model; `/chat/completions` is appended to the accepted base path. Native IDs differ from OpenRouter slugs, and copying a marketplace slug into a native endpoint does not translate it.

Keyless model IDs are exactly `deepseek/deepseek-v4-flash` and `z-ai/glm-5.3-flash`. Qwen, Kimi and other compatible model IDs require BYOK. `:free`, `:online` and other suffixes are not accepted; the translator adds no web search.

HTTPS and approved host/path combinations are required. Userinfo, query strings in the base URL, fragments, unapproved ports, path traversal and redirects are rejected. All resolved IP addresses must pass the public-address check, and the connection uses the verified address set. A public hostname that resolves to even one private address is refused. A redirect never carries the Authorization header to a new destination.

### Field dictionary

Every Dataset record has the base fields below; operation-specific fields may be absent from a notice or a not-found row when no model call occurred. Do not infer zero tokens, zero cost or high confidence from a missing field.

| Field | Meaning |
| --- | --- |
| `rowId` | String form of the zero-based source row index. A source field with the same name is retained under original. |
| `text` | Example original buyer field. Actual nonreserved original columns depend on the supplied row and can contain authorized personal data. |
| `original` | Namespace containing original buyer fields that would collide with Actor-reserved output names. It preserves provenance without overwriting status. |
| `translated` | Object keyed by exact selected dotted paths, containing the translated strings. All selected fields must satisfy the row contract before payment. |
| `pinyin` | Pinyin generated locally from original selected text when enabled. It is not a model-provided translation or a dialect transcript. |
| `traditional` | Local conversion of original selected text into traditional characters when requested. It does not translate the English output back into Chinese. |
| `simplified` | Local conversion of original selected text into simplified characters when requested. Empty object when another script mode is selected. |
| `sourceLanguage` | Heuristic zh, en, zh+en or und based on character presence; null when detection is disabled. This is not a calibrated language classifier. |
| `dialectMarkers` | Observed dictionary markers with heuristic provenance and null confidence. A marker is not a verified identification of a speaker or dialect. |
| `tokens` | Estimated per-row allocation of the batch input/output usage. Integer allocations sum back to returned batch totals. |
| `reasoningTokens` | Nullable estimated per-row share of provider reasoning tokens; integer shares sum to the batch total and are already included in tokens.output. Uses the same UTF-8 input weights as tokens; null when unavailable. |
| `costUsd` | Upstream cost in USD; provider value, dated estimate or null. This is distinct from the Actor result event price. |
| `costSource` | provider, estimate or unknown. Check this before using a number in a cost comparison; null is not zero cost. |
| `priceDate` | Date of the model tariff pin when cost is estimated; null for a provider-reported price. Distinct from the exchange-rate date. |
| `costAllocation` | estimated\_by\_input\_utf8\_bytes. This makes explicit that the batch cost is allocated, rather than independently metered for this row. |
| `batchId` | Run-local batch label. Combine it with the run ID; batch-1 from separate runs is not a shared global identity. |
| `model` | Normalized provider model identifier used for this request. Keep it with the prompt or field configuration when comparing results. |
| `provider` | Selected API host. It identifies the transport provider rather than an independent verification service. |
| `demo` | True on every output row for designated synthetic demo input. Keep it in exports so synthetic material cannot masquerade as buyer data. |
| `schemaVersion` | Contract version, currently 1.0. Preserve it when loading historical runs; a version is not a freshness timestamp. |
| `type` | Record kind: the product result type, notice, or domain\_summary. Filter by kind before interpreting operation-specific fields. |
| `sourceUrl` | The API endpoint used for provider evidence, or null when no call was needed. This is not a dereferenced social source URL. |
| `found` | True only for a complete useful product unit. False includes both correct absence and failure; inspect status and error. |
| `status` | Machine-readable outcome such as ok, not\_found, error, partial, no\_citations or summary. The appropriate subset depends on record kind. |
| `resultCount` | Exactly 1 for a complete result and 0 for free explanatory records. It never reports an estimated number of unseen answers. |
| `partial` | True when this record is incomplete or describes unfinished work. Complete neighboring records can remain false in a partial run. |
| `error` | Empty string for correct absence or a complete result. Nonempty generic code for a failure; credentials and provider error bodies are not copied. |
| `warnings` | Additional interpretation limits or a cap reason. Warnings are data, not instructions for a downstream agent to execute. |
| `checkedAt` | UTC observation timestamp generated during processing. It does not claim when the underlying text was originally published. |
| `evidence` | Operation-specific provenance object or null. It identifies how the row was produced and does not certify factual accuracy. |
| `confidence` | Null unless a supported confidence measure exists. Version 1 does not invent a probability for model output or dictionary classifications. |
| `action` | Suggested mechanical route such as use\_result, review, review\_or\_retry, resume\_remaining or review\_grounding. Your application decides the final action. |

#### Run summary in OUTPUT

| Field | Meaning and consumer action |
| --- | --- |
| `requested` | Work supplied before the Actor's working cap; interpretation follows the product's unit below. |
| `processed` | Units attempted or classified, including failures and correct absence. It is not a billable count. |
| `delivered` | Complete useful units whose Dataset delivery was confirmed. Free notices are counted separately. |
| `paid` | Confirmed result-found units under the active PPE tariff. Local nonmonetized execution can deliver without this count. |
| `free` | Confirmed Dataset records written without a result event, including summaries and notices. |
| `failed` | Free records with a nonempty error. A correct not-found record does not increase this counter. |
| `unprocessed` | Requested units left outside completed processing because of a work, input, money or delivery stop. |
| `partial` | At least part of the requested work is incomplete, erroneous or uncertain. Successful neighbors remain useful. |
| `fatal` | Empty string normally; nonempty means the run must be treated as failed even if some useful rows exist. |
| `deliveryUncertain` | Count of delivery attempts whose outcome could not be confirmed. Stop automatic replay. |
| `budgetExhausted` | Further paid work was refused by the buyer spending gate. It does not invalidate the final paid unit. |
| `replaySafe` | Always false in v1. The Actor has no cross-run exactly-once ledger. |
| `reason` / `stopReason` | Domain-level stop and client-level stop, respectively; preserve both for troubleshooting. |
| `logicalTasks` / `httpAttempts` | Admitted LLM tasks and actual request attempts, which can differ because of retries. |
| `tokenUnits` | Conservative attempt reserves reconciled with valid returned usage. This is a guard counter, not a universal tokenizer. |
| `costBoundUsd` | Accumulated admission estimates, increased when a provider reports a larger known cost. |
| `reportedUpstreamCostUsd` | Sum of provider cost values actually returned, including unsuccessful completion envelopes. |
| `unknownCostAttempts` | Attempts without an authoritative cost value. It prevents a null invoice from looking free. |
| `demoInput` | Whether the Actor used designated synthetic source data; see the product-specific convention. |
| `checkedAt` / `schemaVersion` | Observation timestamp and output contract version. Retain both in exports. |

### Evidence and boundaries

This README is backed by **accepted platform runs on Apify's network** (build 0.1.8, 2026-09-06): happy `EngTjbCehl9U9G7na`, not-found `H15cOP0MHJuZxOPpA`, keyless cap `PJX2qDbdiprjTvdWv`, plus the token-limit golden; all four acceptance goldens passed and the charged event counts below were read back from the run records. Local SDK 3.7.2 tests with a mock OpenAI-compatible server (`tests/`, `proofs/`) cover the failure paths that are not reproduced on the platform on purpose.

Real buyer exports were accepted as well: Douyin run `OBBXabez7skFgfcTL` and Xiaohongshu run `KIdHkKOos9vyRW0d7`, ten paid rows each on exports bought in the Apify Store; both are recorded below.

The two diagrams are the Actor's own 1600×900 illustrations, not screenshots of a listing.

Transport is bounded to 2 MiB per LLM/FX response and 50 MiB of response data per run. The LLM request has a 45-second DNS, connection and body timeout; FX uses 20 seconds. Network failures, HTTP 429 and 5xx responses allow at most two network retries per task, with Retry-After constrained by the run deadline. OpenRouter off-mode HTTP 400 compatibility repeats are separately bounded as described in Thinking models and output tokens. A platform-key 402, 403 or 429 stops after the first attempt and returns a BYOK hint. Malformed JSON, HTML, redirects, HTTP 401 and incomplete response bodies are not retried. HTTP 400 is terminal outside the bounded OpenRouter off-mode compatibility path.

Text and URLs supplied by the buyer are data. The Actor does not execute scripts, download attachments, render web pages or follow citation links. It makes no direct requests to Douyin, Xiaohongshu, Weibo, Zhihu, WeChat, Bilibili, Baidu, Taobao, 1688, JD, Toutiao, Juejin or 36kr. Their names or URLs can occur in source rows and annotations without authorizing collection from them. Search providers perform their own upstream retrieval; excluded-domain settings do not establish independent control over every internal provider request.

Two provider behaviours seen on the accepted runs are handled in code and covered by tests: with reasoning disabled, `deepseek/deepseek-v4-flash` sometimes echoes the input container key instead of `translated`, so the parser accepts the translation under either key as long as the field names and `rowId` match; and long fields can overflow the output budget of a batch, so batches are sized from an estimate of the output tokens (1.6 tokens per character) and a batch that still comes back truncated is halved and retried from the same row, which is why a paid batch never hides a truncated row.

### Decision routing

| Observation | Route | Preserve before proceeding |
| --- | --- | --- |
| Complete result, no fatal error | Send to the product's human or automated review step | Source identity, model, settings, timestamp and evidence fields |
| `found:false`, empty error, zero result count | Classify the defined absence; do not invent a completion | Original selection and the not-found status |
| Free error next to complete results | Keep successful neighbors; isolate failed units | Error code, input index or row ID, run ID |
| `unprocessed > 0` | Prepare a smaller remaining-work batch | Original ordering, delivered identities and cap reason |
| `fatal` or uncertain delivery | Stop automatic replay and reconcile | Run receipt, Dataset contents and the OUTPUT record |

### Integration recipes

For a spreadsheet, export complete results and free notices into separate sheets and keep the raw JSON next to flattened columns: nested translations and original-field collisions do not fit one scalar cell. Count useful results from the base status contract, not from the number of visible lines.

For an API or scheduled workflow, keep the run ID, wait for the terminal status, then read both the Dataset and the KVS `OUTPUT`. A timeout in your orchestration does not prove the Actor failed; recover the saved run ID before resubmitting a whole job. Workflow tools or MCP clients can pass the same JSON contract and route complete rows into a CRM, warehouse or review queue; the Actor itself writes to none of them.

```javascript
const usable = datasetRows.filter(row =>
    row.found === true && row.partial === false &&
    row.resultCount === 1 && row.error === '');
const reconcile = Boolean(output.fatal) || output.deliveryUncertain > 0;
const remaining = output.unprocessed > 0;
```

### Operating guide

Before increasing volume, run a representative sample with empty text, mixed languages, long rows, nested fields and protected terms, define the review criterion in advance and change one setting at a time. A model, prompt or glossary revision can change meaning while structural tests still pass. Keep configuration versions separate from credentials.

During a run the token guard reserves UTF-8 message bytes plus an output reserve before each attempt and reconciles valid provider usage afterwards; unknown usage keeps the reserve debited, so an unsuccessful call cannot bypass the cap. A retry can cost upstream money without producing a billable Actor result.

After partial work, distinguish a deterministic correction from a transient failure. Invalid input requires editing the input. A schema incompatibility requires fixing the schema or choosing a supporting model. A budget or token stop requires a smaller remaining workload or an intentionally authorized limit change. Authentication errors require checking the chosen account. Repeating the same invalid configuration adds no useful evidence and may incur another automatic start.

Results and named baseline storage belong to the buyer's Apify storage context. Configure retention and access in that account and downstream systems; the Actor does not impose a calendar-based deletion policy. Send only source material needed for the task. The buyer is responsible for rights to process supplied data and for evaluating applicable PIPL/GDPR duties, provider terms and cross-border processing requirements. This workflow description is not legal advice or a compliance certification. The Actor does not log source payloads, phone numbers or identity records; errors use generic codes and known credentials are scrubbed from persisted results.

### FAQ

**Does complete mean accurate?** Completion means the provider finished in the required form and mechanical checks passed. Schema validation constrains structure, while factual and linguistic review remain separate decisions.

**Can a run finish without a paid result?** Yes. Correct absence, validation failure, a missing key, a provider error or an admission limit can yield no result-found event. Free records can still make the Dataset nonempty, and the automatic start may still apply.

**Can I use any model or endpoint?** Keyless runs accept only the two reviewed flash IDs. BYOK permits compatible model IDs on the listed host/path pairs. A valid identifier is not proof of account access or feature support. Arbitrary proxies and private endpoints are not accepted.

**Is the evidence on this page live?** The examples are exact records from accepted runs on Apify's network, including two bought Douyin and Xiaohongshu exports; URLs inside rows are retained as strings and are not verified by the Actor.

### Sources and rights

Provider interface references are [OpenRouter web search documentation](https://openrouter.ai/docs/guides/features/plugins/web-search) and [usage accounting documentation](https://openrouter.ai/docs/cookbook/administration/usage-accounting). They are interface references, not a claim that every allowed provider was called in this build. SDK behavior was checked against the installed, exactly pinned Apify 3.7.2 package. Applicable FX rows retain their own route and observation date.

The Actor grants no ownership of source texts, trademarks, linked publications or provider outputs. Obtain data through sources you are authorized to use. Access to an export does not automatically establish a right to republish it. Keep provenance and any source restrictions with shared reports, particularly when results cross customer or organization boundaries.

### Recorded happy, not-found and partial output (accepted platform runs)

The three examples below are exact records from the accepted acceptance runs listed in Evidence and boundaries; strings longer than the page limit are cut with an explicit truncation note, nothing else is edited. Only `checkedAt` and provider latency differ between repeated runs.

#### happy — paid result-found row

Run `EngTjbCehl9U9G7na` on build 0.1.8, 2026-09-06, 3 s, Dataset records: 1, charged events: `{"apify-actor-start": 1, "result-found": 1}`.

Input:

```json
{
 "rows": [
  {
   "text": "你好 #科技",
   "demo": true
  }
 ],
 "maxItems": 1,
 "targetLanguage": "en",
 "glossary": {},
 "batchSize": 5,
 "includePinyin": true,
 "scriptMode": "traditional",
 "detectLanguage": true,
 "baseUrl": "https://openrouter.ai/api/v1",
 "model": "deepseek/deepseek-v4-flash",
 "reasoningMode": "off",
 "maxOutputTokens": 768,
 "maxTotalTokens": 40000,
 "temperature": 0.2,
 "maxConcurrency": 1
}
```

First Dataset record (exact):

```json
{
 "schemaVersion": "1.0",
 "type": "translated_row",
 "sourceUrl": "https://openrouter.ai/api/v1/chat/completions",
 "found": true,
 "status": "ok",
 "resultCount": 1,
 "partial": false,
 "error": "",
 "warnings": [],
 "checkedAt": "2026-09-06T01:39:35.178Z",
 "evidence": {
  "kind": "supplied_data_translation",
  "fields": [
   "text"
  ]
 },
 "confidence": null,
 "action": "use_result",
 "reasoningTokens": 0,
 "text": "你好 #科技",
 "original": {
  "demo": true
 },
 "rowId": "0",
 "demo": true,
 "translated": {
  "text": "Hello #科技"
 },
 "pinyin": {
  "text": "nǐ hǎo   # kē jì"
 },
 "traditional": {
  "text": "你好 #科技"
 },
 "simplified": {},
 "sourceLanguage": "zh",
 "dialectMarkers": [],
 "tokens": {
  "input": 131,
  "output": 31,
  "allocation": "estimated"
 },
 "costUsd": 3.75e-05,
 "costSource": "provider",
 "priceDate": null,
 "costAllocation": "estimated_by_input_utf8_bytes",
 "batchId": "batch-1",
 "model": "deepseek/deepseek-v4-flash",
 "provider": "openrouter.ai"
}
```

OUTPUT record (run summary):

```json
{
 "requested": 1,
 "processed": 1,
 "unprocessed": 0,
 "partial": false,
 "reason": "",
 "demoInput": true,
 "logicalTasks": 1,
 "httpAttempts": 1,
 "tokenUnits": 162,
 "costBoundUsd": 0.000175875,
 "reportedUpstreamCostUsd": 3.75e-05,
 "unknownCostAttempts": 0,
 "stopReason": "",
 "delivered": 1,
 "paid": 1,
 "free": 0,
 "failed": 0,
 "fatal": "",
 "deliveryUncertain": 0,
 "budgetExhausted": false,
 "replaySafe": false,
 "replayNote": "Serialize schedules. No exactly-once ledger; reconcile uncertain delivery before replay.",
 "schemaVersion": "1.0",
 "checkedAt": "2026-09-06T01:39:35.275Z"
}
```

#### not-found — free row, no result charge

Run `H15cOP0MHJuZxOPpA` on build 0.1.8, 2026-09-06, 3 s, Dataset records: 1, charged events: `{"apify-actor-start": 1, "result-found": 0}`.

Input:

```json
{
 "rows": [
  {
   "text": ""
  }
 ],
 "maxItems": 1,
 "targetLanguage": "en",
 "glossary": {},
 "batchSize": 5,
 "includePinyin": true,
 "scriptMode": "traditional",
 "detectLanguage": true,
 "baseUrl": "https://openrouter.ai/api/v1",
 "model": "deepseek/deepseek-v4-flash",
 "reasoningMode": "off",
 "maxOutputTokens": 768,
 "maxTotalTokens": 40000,
 "temperature": 0.2,
 "maxConcurrency": 1
}
```

Dataset record (exact):

```json
{
 "schemaVersion": "1.0",
 "type": "translated_row",
 "sourceUrl": null,
 "found": false,
 "status": "not_found",
 "resultCount": 0,
 "partial": false,
 "error": "",
 "warnings": [],
 "checkedAt": "2026-09-06T01:39:38.687Z",
 "evidence": null,
 "confidence": null,
 "action": "review",
 "reasoningTokens": null,
 "text": "",
 "rowId": "0",
 "demo": false
}
```

#### partial — keyless cap reached, the extra row is never charged

Run `PJX2qDbdiprjTvdWv` on build 0.1.8, 2026-09-06, 8 s, Dataset records: 21, charged events: `{"apify-actor-start": 1, "result-found": 20}`.

Input:

```json
{
 "rows": [
  {
   "text": "中文 0"
  },
  {
   "text": "中文 1"
  },
  "… 19 more rows of the same shape omitted here for length"
 ],
 "maxItems": 21,
 "batchSize": 10,
 "targetLanguage": "en",
 "glossary": {},
 "includePinyin": true,
 "scriptMode": "traditional",
 "detectLanguage": true,
 "baseUrl": "https://openrouter.ai/api/v1",
 "model": "deepseek/deepseek-v4-flash",
 "reasoningMode": "off",
 "maxOutputTokens": 768,
 "maxTotalTokens": 40000,
 "temperature": 0.2,
 "maxConcurrency": 1
}
```

Free notice record (exact):

```json
{
 "schemaVersion": "1.0",
 "type": "notice",
 "sourceUrl": null,
 "found": false,
 "status": "partial",
 "resultCount": 0,
 "partial": true,
 "error": "",
 "warnings": [
  "working_cap"
 ],
 "checkedAt": "2026-09-06T01:39:52.143Z",
 "evidence": null,
 "confidence": null,
 "action": "review",
 "reasoningTokens": null,
 "unprocessed": 1,
 "demo": false
}
```

#### supplied dataset — real Douyin search export (paid rows)

Run `OBBXabez7skFgfcTL` on build 0.1.7, 2026-09-06, 36 s, Dataset records: 11, charged events: `{"apify-actor-start": 1, "result-found": 10}` — 10 paid rows out of 10 requested. The dataset was an export bought in the Apify Store and passed through `datasetId`; the actor never contacted the social platform.

Input:

```json
{
 "datasetId": "LbXVpVXC2wamns1mw",
 "fields": [
  "text",
  "caption"
 ],
 "targetLanguage": "en",
 "batchSize": 5,
 "includePinyin": true,
 "scriptMode": "traditional",
 "detectLanguage": true,
 "maxItems": 10,
 "maxConcurrency": 1,
 "glossary": {},
 "baseUrl": "https://openrouter.ai/api/v1",
 "model": "deepseek/deepseek-v4-flash",
 "reasoningMode": "off",
 "maxOutputTokens": 768,
 "maxTotalTokens": 40000,
 "temperature": 0.2
}
```

First paid Dataset record, reduced to the source fields, the translation, the language heuristic and the token/cost accounting (pinyin and script views are omitted here as well; 71 pass-through fields of the original export such as `action`, `aiMetadata`, `anchors`, `authorMeta`, `awemeType`, `awemeTypeLabel` … are omitted here for length; the actual record carries every original field unchanged):

```json
{
 "text": "电车真的要淘汰燃油车了吗？ 别被网络洗脑了，今天一条视频告诉你到底是选电车还是选燃油车！#燃油车 #电车 #汽车知识分享 #青年创作者成长计划",
 "caption": "别被网络洗脑了，今天一条视频告诉你到底是选电车还是选燃油车！#燃油车 #电车 #汽车知识分享 #青年创作者成长计划",
 "rowId": "0",
 "found": true,
 "status": "ok",
 "partial": false,
 "error": "",
 "sourceLanguage": "zh",
 "translated": {
  "text": "Will electric cars really replace fuel vehicles? Don't be brainwashed by the internet. Today, a video tells you whether to choose an electri… [truncated here for length; the record holds 188 characters]",
  "caption": "Don't be brainwashed by the internet. Today, a video tells you whether to choose an electric car or a fuel car! #燃油车 #电车 #汽车知识分享 #青年创作者成长计划"
 },
 "tokens": {
  "input": 271,
  "output": 207,
  "allocation": "estimated"
 },
 "reasoningTokens": 0,
 "costUsd": 9.179e-05,
 "model": "deepseek/deepseek-v4-flash"
}
```

#### supplied dataset — real Xiaohongshu search export (paid rows)

Run `KIdHkKOos9vyRW0d7` on build 0.1.8, 2026-09-06, 21 s, Dataset records: 11, charged events: `{"apify-actor-start": 1, "result-found": 10}` — 10 paid rows out of 10 requested. The dataset was an export bought in the Apify Store and passed through `datasetId`; the actor never contacted the social platform.

Input: the same shape as the Douyin example with `datasetId: "a2dg49fnBbqJfj8Mn"`, `fields: ["title", "desc"]` and `scriptMode: "traditional"`.

First paid Dataset record, reduced to the source fields, the translation, the language heuristic and the token/cost accounting (pinyin and script views are omitted here as well; 33 pass-through fields of the original export such as `action`, `at_user_list`, `author`, `click_score`, `confidence`, `costAllocation` … are omitted here for length; the actual record carries every original field unchanged):

```json
{
 "title": "9月，Model 3：19.97w起",
 "desc": "⚡️是谁还没有Get一辆梦中情车呀？ 🙋赶紧跟着小金教你怎么提划算！ 🚗裸车价：22.75w（含8k保险补",
 "rowId": "0",
 "found": true,
 "status": "ok",
 "partial": false,
 "error": "",
 "sourceLanguage": "zh+en",
 "translated": {
  "title": "In September, Model 3: starting from 197,900 yuan",
  "desc": "⚡️Who hasn't gotten a dream car yet? 🙋Follow Xiao Jin to learn how to get the best deal! 🚗Naked car price: 227,500 yuan (including 8,000 yua… [truncated here for length; the record holds 160 characters]"
 },
 "tokens": {
  "input": 114,
  "output": 94,
  "allocation": "estimated"
 },
 "reasoningTokens": 0,
 "costUsd": 4.080147727272727e-05,
 "model": "deepseek/deepseek-v4-flash"
}
```

#### Related tools

Related tools for adjacent workflows in data pipelines for AI applications, social platforms and regional directories.

| Actor | What it does |
|---|---|
| [RAG Dataset Builder](https://apify.com/zinin/sitemap-to-knowledge) | Pair it in the data pipelines for AI applications workflow: Turn buyer-authorized public website sitemaps into bounded, source-linked text chunks for RAG, search,... |
| [Live Price Oracle](https://apify.com/zinin/live-price-oracle) | Pair it in the data pipelines for AI applications workflow: Get timestamped DexScreener market observations for up to 100 token contracts or bounded ticker searches |
| [Structured Data Extractor](https://apify.com/zinin/structured-extract) | Pair it in the data pipelines for AI applications workflow: Extract title, meta, JSON-LD, headings, links, emails, and price observations from up to 100 authorized... |
| [Telegram Export Intelligence](https://apify.com/zinin/telegram-channel-intel) | Pair it in the social platforms and regional directories workflow: Turn owner-authorized Telegram message exports into per-post reach context, evidence, confidence, review... |
| [URL to Markdown Converter](https://apify.com/zinin/url-to-markdown) | Pair it in the data pipelines for AI applications workflow: Convert up to 100 authorized public HTML pages into clean Markdown for RAG, AI agents, SEO research, and... |

# Actor input Schema

## `rows` (type: `array`):

Inline buyer export, at most 500 objects. Prefill rows are explicitly synthetic demos. Dataset URLs and collection from social platforms are unsupported. Opaque buyer record. Runtime: 64 KiB per row, depth 8, nested arrays at most 100 entries. Unsafe property paths and secret fields are rejected or removed. Runtime object limit: 200 properties.

## `datasetId` (type: `string`):

Optional 17-character dataset ID read through your SDK permissions. Omit the inline items/rows property entirely when using this field. No dataset URLs. Pages <=100; total <=5000 rows and 10 MiB. Pick the dataset with the resource picker: under the Actor's limited permissions only a dataset referenced through this field is readable (a dataset ID typed elsewhere fails with dataset\_read\_failed).

## `fields` (type: `array`):

Every selected dotted path must be a string. One complete Translated row requires all selected fields and protected spans. No more than 20 paths.

## `targetLanguage` (type: `string`):

Language code or short label passed to the model, such as en, zh or de. Validate suitability with your selected provider on representative data.

## `glossary` (type: `object`):

At most 100 source-to-output mappings, each key and value <=100 characters. Longest source terms win. Protected spans are restored to the mapped value.

## `batchSize` (type: `integer`):

At most 10. Batches shrink before requests to fit byte/token units and the number of rows the current buyer budget can cover.

## `includePinyin` (type: `boolean`):

Generate pinyin locally from the original Chinese text. Names, polyphonic characters and regional usage can need human review.

## `scriptMode` (type: `string`):

Convert original source strings to traditional or simplified Chinese using OpenCC, or choose none. These fields describe source text, not the translated answer.

## `detectLanguage` (type: `boolean`):

Use visible script to label zh, en, zh+en or und. Dialect markers are explicitly heuristic with null confidence; no identity or origin inference.

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

Count of source rows considered in this run, including free failures. Platform maximum 20; dataset ingestion independently caps at 5000 rows and 10 MiB.

## `apiKey` (type: `string`):

Optional buyer credential for the selected endpoint. Never copied to results. Empty uses the platform key only with OpenRouter. Buyer credentials are never replaced after a provider error. Runtime limit: 512 characters.

## `baseUrl` (type: `string`):

HTTPS base path, without /chat/completions. Only documented host/path pairs are accepted. Custom native endpoints require apiKey. Search supports OpenRouter only. No query, credentials, fragments or redirects.

## `model` (type: `string`):

Keyless: deepseek/deepseek-v4-flash or z-ai/glm-5.3-flash only. Qwen, Kimi and other model IDs require BYOK. The provider must support this model and operation.

## `reasoningMode` (type: `string`):

OpenRouter only: off disables thinking, or uses low effort for z-ai/ models. Off-mode HTTP 400 retries with low effort, then provider defaults, within run caps. Direct endpoints retain provider thinking settings.

## `maxOutputTokens` (type: `integer`):

Upper completion allowance per call, including reasoning tokens. Default 768; platform hard maximum 1024; BYOK hard maximum 4096. Length-truncated answers are free incomplete results.

## `maxTotalTokens` (type: `integer`):

UTF-8 message bytes plus completion reserve before each attempt, reconciled with valid usage afterward. Platform hard maximum 40000; BYOK 2000000. Unknown usage consumes full reserve.

## `temperature` (type: `number`):

Sampling temperature passed to the provider. Repeated runs can differ even at a low value. Does not establish factual correctness.

## `maxConcurrency` (type: `integer`):

Version 1 processes one call at a time. Billing and delivery are serialized. Schedule citation comparisons without overlapping runs.

## Actor input object example

```json
{
  "rows": [
    {
      "text": "今天的新品很好用 #科技",
      "demo": true
    },
    {
      "text": "支持中文和英文 🌟",
      "demo": true
    },
    {
      "text": "物流速度很快",
      "demo": true
    },
    {
      "text": "这个价格很合适",
      "demo": true
    },
    {
      "text": "@demo 下次再来 #购物",
      "demo": true
    }
  ],
  "datasetId": "12345678901234567",
  "fields": [
    "text"
  ],
  "targetLanguage": "en",
  "glossary": {},
  "batchSize": 5,
  "includePinyin": true,
  "scriptMode": "traditional",
  "detectLanguage": true,
  "maxItems": 5,
  "baseUrl": "https://openrouter.ai/api/v1",
  "model": "deepseek/deepseek-v4-flash",
  "reasoningMode": "off",
  "maxOutputTokens": 512,
  "maxTotalTokens": 40000,
  "temperature": 0.2,
  "maxConcurrency": 1
}
```

# Actor output Schema

## `results` (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 = {
    "rows": [
        {
            "text": "今天的新品很好用 #科技",
            "demo": true
        },
        {
            "text": "支持中文和英文 🌟",
            "demo": true
        },
        {
            "text": "物流速度很快",
            "demo": true
        },
        {
            "text": "这个价格很合适",
            "demo": true
        },
        {
            "text": "@demo 下次再来 #购物",
            "demo": true
        }
    ],
    "fields": [
        "text"
    ],
    "targetLanguage": "en",
    "glossary": {},
    "batchSize": 5,
    "includePinyin": true,
    "scriptMode": "traditional",
    "detectLanguage": true,
    "maxItems": 5,
    "baseUrl": "https://openrouter.ai/api/v1",
    "model": "deepseek/deepseek-v4-flash",
    "maxOutputTokens": 768,
    "maxTotalTokens": 40000,
    "temperature": 0.2,
    "maxConcurrency": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("zinin/chinese-social-media-dataset-translator").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 = {
    "rows": [
        {
            "text": "今天的新品很好用 #科技",
            "demo": True,
        },
        {
            "text": "支持中文和英文 🌟",
            "demo": True,
        },
        {
            "text": "物流速度很快",
            "demo": True,
        },
        {
            "text": "这个价格很合适",
            "demo": True,
        },
        {
            "text": "@demo 下次再来 #购物",
            "demo": True,
        },
    ],
    "fields": ["text"],
    "targetLanguage": "en",
    "glossary": {},
    "batchSize": 5,
    "includePinyin": True,
    "scriptMode": "traditional",
    "detectLanguage": True,
    "maxItems": 5,
    "baseUrl": "https://openrouter.ai/api/v1",
    "model": "deepseek/deepseek-v4-flash",
    "maxOutputTokens": 768,
    "maxTotalTokens": 40000,
    "temperature": 0.2,
    "maxConcurrency": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("zinin/chinese-social-media-dataset-translator").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 '{
  "rows": [
    {
      "text": "今天的新品很好用 #科技",
      "demo": true
    },
    {
      "text": "支持中文和英文 🌟",
      "demo": true
    },
    {
      "text": "物流速度很快",
      "demo": true
    },
    {
      "text": "这个价格很合适",
      "demo": true
    },
    {
      "text": "@demo 下次再来 #购物",
      "demo": true
    }
  ],
  "fields": [
    "text"
  ],
  "targetLanguage": "en",
  "glossary": {},
  "batchSize": 5,
  "includePinyin": true,
  "scriptMode": "traditional",
  "detectLanguage": true,
  "maxItems": 5,
  "baseUrl": "https://openrouter.ai/api/v1",
  "model": "deepseek/deepseek-v4-flash",
  "maxOutputTokens": 768,
  "maxTotalTokens": 40000,
  "temperature": 0.2,
  "maxConcurrency": 1
}' |
apify call zinin/chinese-social-media-dataset-translator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zinin/chinese-social-media-dataset-translator"
        }
    }
}
```

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/bOAD7gcEIRI0AvcLD/builds/24fW2cCnPCnLg2vXK/openapi.json