# Chinese LLM Bulk Prompt Runner DeepSeek Qwen Kimi (`zinin/chinese-llm-bulk-prompt-runner`) Actor

Run Chinese LLM prompts in bulk with DeepSeek, Qwen or Kimi. Deduplicate answers, validate JSON and export token usage with bounded buyer costs.

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

## Pricing

from $2.80 / 1,000 answers

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 LLM Bulk Prompt Runner DeepSeek Qwen Kimi

Turn Chinese LLM prompts into deduplicated answers, validated JSON and explicit usage records for each completed job.

**Evidence status: private builds accepted on 2026-09-06.** Every input/output example below is an exact dataset row or OUTPUT record from the accepted acceptance runs on build 0.1.3; every later build passed the same four goldens before publication. The examples come 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 LLM Bulk Prompt Runner takes buyer-supplied objects, selects literal fields, renders a prompt and produces one Answer for each unique completed prompt and configuration. It adds source-index tracking, within-run deduplication, structural JSON validation, upstream usage and USD/CNY reporting to a bounded sequence of compatible chat calls. Empty or missing referenced values become free not-found records. Refusals, unfinished generations and invalid structured answers become free errors instead of complete paid Answers.

A result retains the original input after secret removal, the final prompt, model and provider. The first occurrence has `inputIndex`; later matching inputs appear in `duplicateInputIndexes`. Deduplication uses the final prompt, model, temperature, response mode and schema. Two different source objects can share one Answer if their selected values render the same prompt. Conversely, changing the prompt text changes the job. Deduplication is local to this run and does not imply a cache across future runs.

### Who uses it

Analysts use it to turn a stable set of Chinese business topics into comparable short answers. Product operations teams use bounded structured output to organize their own catalog notes or internal research excerpts. Localization teams can generate candidate summaries for review when full field-by-field translation is unnecessary. Developers can compare prompt revisions against a saved source sample without writing their own billing, input-limit and response-shape plumbing.

This product is suitable when the buyer already has the text or topic to process and can define what a useful output looks like. It does not collect a social feed, discover private records, run a browser or verify claims against the web. For decisions requiring current external evidence, a fluent text answer alone is inadequate. Keep the source material and human acceptance criterion beside the generated Answer.

#### Prompt and schema semantics

`promptTemplate` accepts literal placeholders such as `{{topic}}` or `{{article.title}}` only when those paths occur in `fieldsToUse`. Missing, null or empty-string placeholder values make that input not-found without a model call. Literal text outside the placeholders remains unchanged. Source values containing dollar expressions or brace-like text are inserted as inert data. There is no expression interpreter, function call syntax or hidden preprocessing of a row.

Rendering enforces the input-unit limit incrementally. Repeating a placeholder hundreds of times cannot allocate an unrestricted source-by-template product before the guard acts. The full request check also includes message framing and a JSON schema when one is used. An otherwise valid 64 KiB source object can therefore exceed a prompt's 8,000-unit platform allowance and be refused; row storage size and LLM admission size are different constraints.

In `json_schema` mode, the client requests a structured answer and the Actor independently parses and validates it before payment. Supported schema keywords are type, properties, required, additionalProperties, items, maxItems, minItems, maxLength, minLength, minimum, maximum, enum, const, description and title. Object/array complexity is bounded; array schemas need `maxItems` no larger than 100. Remote references, recursive references, regular-expression patterns and combinators are rejected before calling the provider.

A complete `stop` response is not sufficient when the returned JSON violates the requested shape. Such a response has `schema_error`, no result event and any available upstream usage preserved as cost evidence. Provider refusal and length-truncated output likewise remain incomplete. The Actor does not auto-repair invalid JSON with additional hidden calls or silently weaken a schema to make an answer pass.

#### Cost conversion and result identity

The first useful answer triggers one public FX GET for the run. A valid CNY-base response supplies a dated USD rate, whose unrounded reciprocal converts USD cost into CNY. If the request is unavailable or malformed, the Actor uses the 2026-09-04 pin, CNY→USD 0.14901, and marks `rateStale:true`. No paid LLM answer is fabricated to establish an FX result. A run stopped before useful answers needs no FX call.

`costUsd` and `costCny` remain upstream model-cost fields, separate from the planned $0.004 Answer event. A provider-reported amount takes precedence over a dated model-price estimate. An unknown cost remains null. `latencyMs` measures the final completion attempt rather than total run time, and `tokensIn`/`tokensOut` are valid returned counts rather than a tokenization claim about arbitrary provider models.

For this Actor, `requested` counts supplied rows; `uniqueRequested` counts prompt jobs after deduplication; `duplicates` is the difference among retained inputs. `processed` counts classified jobs, including correct absence and free errors. Use this distinction when choosing remaining work. Do not assume that twenty paid Answers imply exactly twenty original rows were represented, because multiple source indexes can share each Answer.

### Commercial playbooks

#### Controlled market-topic briefing

Prepare a small owned topic list and use one prompt that asks for the same kind of short explanation for every topic. Keep a content review column outside the Actor. Run the prefill-sized sample, review unsupported claims, then process the remaining topics with the accepted prompt revision. Deliver a report that distinguishes model-generated interpretations from separately cited facts. The commercial value is consistent preparation and traceable review, not guaranteed research accuracy.

#### Catalog tagging with a bounded vocabulary

Define a supported object schema whose category field uses a short enum, and provide only the fields required for classification. Retain the source identifier in the input object. Review the rejected `schema_error` rows separately from valid structured candidates. A valid category can still be wrong for the product, so use a human sample or domain rule before applying tags to a live catalog. Save both schema and prompt versions with the accepted results.

#### Prompt regression workbench

Take a stable sample containing duplicates, blanks and an intentionally hard example. Run one configuration at a time and compare usable answers, structural failure rates, provider cost source and completion reasons. Avoid comparing only average latency or the cheapest reported token value. A revised prompt that creates more incomplete outputs can be operationally worse even when its successful answers look attractive. This Actor provides observations; the buyer defines the acceptance threshold.

#### Integration detail: stable source joins

Use `inputIndex` and `duplicateInputIndexes` to map an Answer back to all original inputs represented in the run. Keep the original input ordering outside the Actor. For an input Dataset, record its ID and a stable snapshot or export; a later mutable Dataset can assign different positions to the same object. When importing into a warehouse, store one Answer observation and a separate mapping table of represented source indexes rather than duplicating the charge across every input reference.

### 中文说明

批量提示词处理：把自有数据中的 `topic` 等字段填入 `{{topic}}`，获得完整回答或经过结构校验的 JSON。示例主题为“中国电商”“中国新能源汽车”。相同最终提示词在本次运行内去重，`duplicateInputIndexes` 保留重复输入的位置。缺字段、未完成回答和 JSON 校验失败不收取结果事件费，但启动费可能已产生。无买家密钥仅支持 `deepseek/deepseek-v4-flash` 与 `z-ai/glm-5.3-flash`；Qwen、Kimi 需要 BYOK。本地示例为模拟数据，不是实时模型质量证明。

![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. The platform credential must first be configured by the operator; without it the result reports `missing_key` and cannot demonstrate useful acceptance. Alternatively, enter a buyer credential in the secret input field and select 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 planned pricing is **$0.005 per automatic run start plus $0.004 per Answer**. The result event is `result-found`. One complete Answer causes one atomic SDK push with that event. The Actor never manually charges a start event. This is draft pricing for review; no listing or cloud price was changed during this local build. The platform's displayed price and the run receipt must be checked during acceptance before treating this amount as a published offer.

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 current buyer budget can cover. Before each paid push it reads the current tariff and remaining money again inside the serialized delivery section. It conservatively checks microdollars rather than copying the SDK's rounded result-count calculation. The final successfully charged row remains a delivered result even if the SDK signals that the spending limit has now been 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 causes a failed run. The Actor does not write explanatory Dataset records under unsafe automatic billing; it uses a generic error log and the failed run status. An uncertain write or charge also stops processing. `deliveryUncertain` requires reconciliation before a retry because a remote write may have succeeded even if its acknowledgement was lost.

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.

#### `items` — Input items

Type: `array`. Default/sample: `[{"topic": "中国电商"}, {"topic": "中国新能源汽车"}, {"topic": "中国人工智能"}]`. Bounds: maxItems=500.

Inline buyer objects, at most 500. Mutually exclusive with datasetId. Useful results follow unique completed prompts; duplicates keep source indexes.

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

#### `fieldsToUse` — Fields available to the template

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

Up to 20 dotted paths, each <=80 characters. Only these paths can appear in literal {{field}} placeholders. No functions or executable expressions.

#### `promptTemplate` — Literal prompt template

Type: `string`. Default/sample: `"用两句话解释{{topic}}的常见商业场景。"`. Bounds: maxLength=8000.

Insert selected fields using {{topic}} or another selected dotted path. No expression execution. Missing or empty referenced values yield a free not-found row.

#### `responseMode` — Answer format

Type: `string`. Default/sample: `"text"`. Bounds: values: text, json\_schema.

Text accepts a nonempty completed answer. json\_schema additionally requires a bounded supported schema and a matching parsed response.

#### `jsonSchema` — Bounded response JSON schema

Type: `object`. Default/sample: `"omitted"`. Bounds: maxProperties=20.

Only with json\_schema mode. No $ref, patterns, combinators or remote references. Arrays require maxItems <=100. Maximum 16 KiB, depth 6 and 200 nodes.

#### `deduplicate` — Deduplicate final prompts

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

Identical final prompt, model and response settings share one paid Answer. Later input indexes are recorded in duplicateInputIndexes. Cross-run deduplication is not provided.

#### `maxItems` — Maximum processed unique prompts

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

Working cap after prompt deduplication, including failed or empty work. Platform additionally stops at 20 rows/tasks. Remaining jobs produce a free partial notice.

#### `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`): DeepSeek v4 Flash with provider defaults hit `length` with null content on 1/3 prompts and spent up to 3 435 reasoning tokens on another; with `off` it answered 3/3 in 59–78 output tokens and 0 reasoning tokens. GLM 5.3 Flash hit `length` 3/3 with defaults, rejected `enabled: false` with HTTP 400 and answered 3/3 with `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 |

This table describes the shared transport allowlist, not live certification of every model or provider feature. The citation analyzer supports only the OpenRouter row for grounded search. Other actors append `/chat/completions` to an accepted base path. Native IDs can differ from OpenRouter slugs; copying a marketplace slug into a native endpoint does not translate it automatically. JSON schema and other model capabilities remain conditional on provider support.

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` and arbitrary suffixes are not accepted. Only the citation analyzer accepts an optional `:online` suffix, normalizing it to the base model plus a single web plugin. The runner and translator do not add 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. Optional operation-specific fields may be absent from a validation notice or a not-found row when no model call occurred. Do not infer zero tokens, zero cost, an empty answer or high confidence from a missing field. Normalize absent analytical values to null in your warehouse while retaining the original JSON for audit.

| Field | Meaning |
| --- | --- |
| `inputIndex` | Zero-based position in the supplied row list. For deduplicated jobs this is the first occurrence; other indices are recorded separately. |
| `input` | Original selected source object after secret-field removal and credential redaction. Additional buyer fields can support later reconciliation. |
| `prompt` | Final literal prompt sent for the result. Field interpolation is inert; this value is not executable JavaScript. |
| `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. |
| `answer` | Completed text returned by the model, after credential redaction. It can still contain unsupported factual statements and requires contextual review. |
| `json` | Locally parsed and validated JSON in json\_schema mode; null in text mode or when structural validation fails. |
| `tokensIn` | Provider prompt-token count when it is a valid nonnegative integer; otherwise null. Distinct from the admission guard tokenUnits. |
| `tokensOut` | Provider completion-token count when valid; otherwise null. Do not replace missing usage with a fabricated measured value. |
| `reasoningTokens` | Nonnegative integer provider reasoning usage, or null when unavailable/invalid. Already included in tokensOut; do not add it again. |
| `costUsd` | Upstream cost in USD; provider value, dated estimate or null. This is distinct from the Actor result event price. |
| `costCny` | USD cost multiplied by the unrounded USD-to-CNY reciprocal rate. Null if upstream cost is unknown. |
| `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. |
| `rateDate` | Date carried by the exchange-rate response, or 2026-09-04 for the explicit fallback pin. |
| `rateSource` | Exact public FX route or named dated pin. Pair with rateStale; it is not the source of provider model pricing. |
| `rateStale` | True for the dated fallback. A successful rate response preserves its own date, which can precede the run date. |
| `latencyMs` | Elapsed time around the final completion request, when an envelope was returned. Retry waits and prior attempts are not an end-to-end latency metric. |
| `duplicateInputIndexes` | Zero-based later inputs sharing the same final prompt and settings in this run. They receive no separate result event. |
| `finishReason` | Provider completion reason. Only stop without a refusal qualifies for a complete paid answer; length and refusal are incomplete. |
| `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.3, 2026-09-06; later builds passed the same suite): happy `ITvolg11ghcejhdPr`, not-found `ZfuWmm4S7klkLOErg`, keyless cap `U2e6jhUweQo4QkJp8`, 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.

Production acceptance requires a useful completed result and its result-found receipt; missing-key errors do not qualify. The translator also needs an accepted real buyer export. Marked synthetic samples cannot replace that evidence.

The diagrams on this page are local draft assets: two distinct SVG sources and WebP exports at 1600×900. Their local dimensions and bytes can be checked in the proof manifest. Immutable remote asset URLs and four real Store screenshots are release evidence still to be supplied by the publisher. Local illustrations are not screenshots of a listing and do not imply that a public listing exists.

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.

### 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 |
| Provider 402/403/429 on platform key | Review provider availability or intentionally select BYOK | The stopped run summary; no silent credential switch |
| `fatal` or uncertain delivery | Stop automatic replay and reconcile | Run receipt, Dataset contents and the OUTPUT record |
| New configuration or unfamiliar model | Run a representative small sample | Prompt/field version, expected output shape and review notes |

### Integration recipes

For a spreadsheet, export complete results and free notices into separate sheets. Preserve raw JSON alongside flattened columns: arrays of citations, nested translations and original-field collisions do not fit one scalar cell. Set destination column types explicitly for IDs and source strings, including strings that a spreadsheet might otherwise interpret as formulas. Count useful results from the base status contract rather than the number of visible lines.

For an API or scheduled workflow, retain the run ID, wait for its terminal status, then obtain both the Dataset and KVS `OUTPUT`. A timeout in your orchestration does not prove the Actor failed to run. Recover the saved run ID before resubmitting a whole job. Keep credentials in a secret store. The build's local actor names do not establish an available public listing; deployment and buyer access must exist before production use.

Workflow tools or MCP clients can pass the same JSON contract and route complete results into a CRM, warehouse or review queue. This Actor does not write to those destinations itself. Keep a business job ID outside the Actor, map product identities deliberately and review generated interpretations before replacing authoritative customer records. Use run ID plus product identity as an observation key, with a separate logical-job key for reconciliation across reruns.

```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;
// Review useful observations and reconcile existing work before retrying.
```

This example processes already obtained data. Add the product checks described below, retain the raw JSON, and distinguish business approval from mechanical result completeness.

### Operating guide

Before increasing volume, choose a representative sample containing empty text, mixed languages, long rows, nested fields, protected terms or a low-evidence query as appropriate. Define an output review criterion in advance. Change one significant setting at a time and retain the prior input. A model, prompt, glossary or query revision can change meaning while structural tests still pass. Store configuration versions separately from credentials; redaction is not a reason to place a key inside source material.

During a run, the Actor processes calls sequentially. The token guard uses UTF-8 message bytes plus an output reserve before each attempt, then reconciles valid provider usage. Chinese characters can consume several byte units each. Unknown or invalid usage keeps the reserve debited, so unsuccessful calls cannot bypass the cap by producing no useful answer. Watch useful results, free errors, unknown-cost attempts and provider-reported cost together. 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.

If delivery is uncertain, inspect the existing Dataset and receipt before retrying. Keep successful neighboring results and reconstruct the remaining set using source IDs or the query/model pair, not free-notice row numbers. The Actor reports `replaySafe:false` because it cannot provide exactly-once processing across separate runs, process crashes or ambiguous acknowledgements. Serialize recurring schedules that share citation baseline settings.

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.

**Can I safely retry everything?** Not automatically. Inspect the existing run and its receipt first. The Actor has no cross-run delivery or billing ledger and a repeated complete result can incur another start, upstream request and result event.

**Are the links and demo evidence verified live?** No. URLs are retained as strings. Local fixtures prove software behavior, not source truth, language accuracy, commercial margin or a public Store quality score. Production acceptance remains a separate release step.

### 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 `ITvolg11ghcejhdPr` on build 0.1.3, 2026-09-06, 4 s, Dataset records: 1, charged events: `{"apify-actor-start": 1, "result-found": 1}`.

Input:

```json
{
 "items": [
  {
   "topic": "中国电商"
  }
 ],
 "maxItems": 1,
 "promptTemplate": "用两句话解释{{topic}}的常见商业场景。",
 "responseMode": "text",
 "deduplicate": 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": "answer",
 "sourceUrl": "https://openrouter.ai/api/v1/chat/completions",
 "found": true,
 "status": "ok",
 "resultCount": 1,
 "partial": false,
 "error": "",
 "warnings": [],
 "checkedAt": "2026-09-06T00:46:45.792Z",
 "evidence": {
  "kind": "model_response",
  "inputIndex": 0
 },
 "confidence": null,
 "action": "use_result",
 "reasoningTokens": 0,
 "inputIndex": 0,
 "input": {
  "topic": "中国电商"
 },
 "prompt": "用两句话解释中国电商的常见商业场景。",
 "model": "deepseek/deepseek-v4-flash",
 "provider": "openrouter.ai",
 "answer": "中国电商的常见商业场景是：消费者通过平台（如淘宝、京东）搜索商品，下单后由商家或平台物流配送至家中；同时，直播带货（如抖音、快手）让主播实时展示商品，用户边看边买，形成“人找货”与“货找人”并存的模式。",
 "json": null,
 "tokensIn": 15,
 "tokensOut": 69,
 "costUsd": 1.377e-05,
 "costCny": 9.240990537547816e-05,
 "costSource": "provider",
 "priceDate": null,
 "rateDate": "2026-09-04",
 "rateSource": "https://api.frankfurter.dev/v1/latest?from=CNY&to=USD",
 "rateStale": false,
 "latencyMs": 1295,
 "duplicateInputIndexes": [],
 "finishReason": "stop",
 "usdToCny": 6.710958996040534
}
```

OUTPUT record (run summary):

```json
{
 "requested": 1,
 "processed": 1,
 "unprocessed": 0,
 "uniqueRequested": 1,
 "duplicates": 0,
 "partial": false,
 "reason": "",
 "completed": 1,
 "logicalTasks": 1,
 "httpAttempts": 1,
 "tokenUnits": 84,
 "costBoundUsd": 0.00014370000000000002,
 "reportedUpstreamCostUsd": 1.377e-05,
 "unknownCostAttempts": 0,
 "stopReason": "",
 "demoInput": false,
 "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-06T00:46:45.874Z"
}
```

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

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

Input:

```json
{
 "items": [
  {
   "topic": ""
  }
 ],
 "maxItems": 1,
 "promptTemplate": "用两句话解释{{topic}}的常见商业场景。",
 "responseMode": "text",
 "deduplicate": 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": "answer",
 "sourceUrl": null,
 "found": false,
 "status": "not_found",
 "resultCount": 0,
 "partial": false,
 "error": "",
 "warnings": [],
 "checkedAt": "2026-09-06T00:46:50.078Z",
 "evidence": null,
 "confidence": null,
 "action": "review",
 "reasoningTokens": null,
 "inputIndex": 0,
 "input": {
  "topic": ""
 },
 "duplicateInputIndexes": []
}
```

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

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

Input:

```json
{
 "items": [
  {
   "topic": "0"
  },
  {
   "topic": "1"
  },
  {
   "topic": "2"
  },
  {
   "topic": "3"
  },
  {
   "topic": "4"
  },
  {
   "topic": "5"
  },
  {
   "topic": "6"
  },
  {
   "topic": "7"
  },
  {
   "topic": "8"
  },
  {
   "topic": "9"
  },
  {
   "topic": "10"
  },
  {
   "topic": "11"
  },
  {
   "topic": "12"
  },
  {
   "topic": "13"
  },
  {
   "topic": "14"
  },
  {
   "topic": "15"
  },
  {
   "topic": "16"
  },
  {
   "topic": "17"
  },
  {
   "topic": "18"
  },
  {
   "topic": "19"
  },
  {
   "topic": "20"
  }
 ],
 "maxItems": 21,
 "promptTemplate": "用两句话解释{{topic}}的常见商业场景。",
 "responseMode": "text",
 "deduplicate": 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-06T00:48:07.372Z",
 "evidence": null,
 "confidence": null,
 "action": "resume_remaining",
 "reasoningTokens": null,
 "unprocessed": 1
}
```

OUTPUT record (run summary):

```json
{
 "requested": 21,
 "processed": 20,
 "unprocessed": 1,
 "uniqueRequested": 21,
 "duplicates": 0,
 "partial": true,
 "reason": "working_cap",
 "completed": 20,
 "logicalTasks": 20,
 "httpAttempts": 20,
 "tokenUnits": 1813,
 "costBoundUsd": 0.0028603500000000002,
 "reportedUpstreamCostUsd": 0.00035423603999999996,
 "unknownCostAttempts": 0,
 "stopReason": "",
 "demoInput": false,
 "delivered": 20,
 "paid": 20,
 "free": 1,
 "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-06T00:48:07.418Z"
}
```

#### Related tools

Related tools for adjacent workflows in AI and search visibility, data pipelines for AI applications.

| Actor | What it does |
|---|---|
| [LLM Brand Visibility Tracker](https://apify.com/zinin/llm-brand-visibility) | Pair it in the AI and search visibility workflow: For each query that matters, check whether AI assistants recommend YOUR brand — and which competitors they... |
| [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... |
| [AI Answer & Citation Change Monitor](https://apify.com/zinin/ai-answer-change-alert) | Pair it in the AI and search visibility workflow: Monitor grounded AI answers by query, model, and language; detect rewrites and cited-domain additions or... |
| [AI Crawler Access Checker](https://apify.com/zinin/ai-crawler-access-checker) | Pair it in the AI and search visibility workflow: Audit up to 100 sites for 16 AI crawler policies |
| [AI Overview Citation Tracker](https://apify.com/zinin/ai-overview-tracker) | Pair it in the AI and search visibility workflow: Track which public URLs and domains selected grounded AI models cite for buyer-supplied queries |

# Actor input Schema

## `items` (type: `array`):

Inline buyer objects, at most 500. Mutually exclusive with datasetId. Useful results follow unique completed prompts; duplicates keep source indexes. 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).

## `fieldsToUse` (type: `array`):

Up to 20 dotted paths, each <=80 characters. Only these paths can appear in literal {{field}} placeholders. No functions or executable expressions.

## `promptTemplate` (type: `string`):

Insert selected fields using {{topic}} or another selected dotted path. No expression execution. Missing or empty referenced values yield a free not-found row.

## `responseMode` (type: `string`):

Text accepts a nonempty completed answer. json\_schema additionally requires a bounded supported schema and a matching parsed response.

## `jsonSchema` (type: `object`):

Only with json\_schema mode. No $ref, patterns, combinators or remote references. Arrays require maxItems <=100. Maximum 16 KiB, depth 6 and 200 nodes.

## `deduplicate` (type: `boolean`):

Identical final prompt, model and response settings share one paid Answer. Later input indexes are recorded in duplicateInputIndexes. Cross-run deduplication is not provided.

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

Working cap after prompt deduplication, including failed or empty work. Platform additionally stops at 20 rows/tasks. Remaining jobs produce a free partial notice.

## `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
{
  "items": [
    {
      "topic": "中国电商"
    },
    {
      "topic": "中国新能源汽车"
    },
    {
      "topic": "中国人工智能"
    }
  ],
  "datasetId": "12345678901234567",
  "fieldsToUse": [
    "topic"
  ],
  "promptTemplate": "用两句话解释{{topic}}的常见商业场景。",
  "responseMode": "text",
  "jsonSchema": {
    "type": "object",
    "properties": {
      "summary": {
        "type": "string"
      }
    },
    "required": [
      "summary"
    ],
    "additionalProperties": false
  },
  "deduplicate": true,
  "maxItems": 3,
  "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 = {
    "items": [
        {
            "topic": "中国电商"
        },
        {
            "topic": "中国新能源汽车"
        },
        {
            "topic": "中国人工智能"
        }
    ],
    "fieldsToUse": [
        "topic"
    ],
    "promptTemplate": "用两句话解释{{topic}}的常见商业场景。",
    "responseMode": "text",
    "deduplicate": true,
    "maxItems": 3,
    "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-llm-bulk-prompt-runner").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 = {
    "items": [
        { "topic": "中国电商" },
        { "topic": "中国新能源汽车" },
        { "topic": "中国人工智能" },
    ],
    "fieldsToUse": ["topic"],
    "promptTemplate": "用两句话解释{{topic}}的常见商业场景。",
    "responseMode": "text",
    "deduplicate": True,
    "maxItems": 3,
    "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-llm-bulk-prompt-runner").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 '{
  "items": [
    {
      "topic": "中国电商"
    },
    {
      "topic": "中国新能源汽车"
    },
    {
      "topic": "中国人工智能"
    }
  ],
  "fieldsToUse": [
    "topic"
  ],
  "promptTemplate": "用两句话解释{{topic}}的常见商业场景。",
  "responseMode": "text",
  "deduplicate": true,
  "maxItems": 3,
  "baseUrl": "https://openrouter.ai/api/v1",
  "model": "deepseek/deepseek-v4-flash",
  "maxOutputTokens": 768,
  "maxTotalTokens": 40000,
  "temperature": 0.2,
  "maxConcurrency": 1
}' |
apify call zinin/chinese-llm-bulk-prompt-runner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zinin/chinese-llm-bulk-prompt-runner"
        }
    }
}

```

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/WlrWeNdTSGo0OsO15/builds/XZPxBrMheXOoSSOwf/openapi.json