# X/Twitter to Chinese Social Post Generator (`shadowell/x-to-chinese-post`) Actor

- **URL**: https://apify.com/shadowell/x-to-chinese-post.md
- **Developed by:** [FENG JIE](https://apify.com/shadowell) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$50.00 / 1,000 post drafts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## X/Twitter to Chinese Social Post Generator

Draft Weibo, Toutiao, and Xiaohongshu copy from public X posts.

This Actor **never publishes** anywhere. It does not call Weibo, Toutiao, Xiaohongshu, or the X write API. It does not ask for an X login, password, or cookies. You review the dataset and post it yourself, and only for content you own or are allowed to reuse.

### Disclaimer

Use this Actor only for posts you created or have permission to repost. A draft is not a license. Risk flags are warnings, not legal advice and not a guarantee that a platform will accept the copy. The Actor does not check your publishing rights beyond the flags below.

### What a run does

1. Reads the X posts you point at.
2. Optionally asks your own OpenAI-compatible model to rewrite each post into the styles you selected.
3. Pushes one dataset item per post, including source fields, media URLs, drafts, and risk flags.
4. Charges one `post-draft` event after a draft is successfully produced, then stops if that charge hits the run's max total charge.

Failed posts are saved with `status: "failed"` and are not charged. `skipGeneration: true` extracts only and does not charge.

### Input

| Field | Required | Default | Purpose |
| --- | --- | --- | --- |
| `postUrls` | yes (the field) | — | Public `x.com` or `twitter.com` status URLs. May be empty when `handles` or `searchKeyword` is set. |
| `handles` | no | `[]` | X handles, with or without `@`. Up to 20. |
| `searchKeyword` | no | empty | One X search keyword. |
| `maxItems` | no | `10` | Posts kept per handle and for the keyword. Range 1–100. |
| `styles` | no | all three | `weibo`, `toutiao`, `xiaohongshu`. |
| `llmApiKey` | required unless `skipGeneration` | — | Secret. Your key. Sent only to `llmBaseUrl`. |
| `llmBaseUrl` | no | `https://api.openai.com/v1` | OpenAI-compatible base URL. Must be a public http(s) URL with no userinfo. |
| `llmModel` | no | `gpt-4o-mini` | Model name. |
| `proxyConfiguration` | no | none | Apify proxy for no-login HTTP fetches only. |
| `skipGeneration` | no | `false` | Extraction-only test mode. |
| `extractor` | no | `auto` | `auto`, `syndication`, or `store`. |
| `xScraperActorId` | no | see below | Store actor used for handles, search, and URL fallback. |

There is no cookie, password, or session field. Do not add one.

### Extraction and cost

Direct status URLs, in `auto` and `syndication` mode, are read from X's public embed endpoint:

`https://cdn.syndication.twimg.com/tweet-result`

That request uses the same token the embed iframe computes from the status id. No X account is involved. If the embed fails, the run tries the public `api.fxtwitter.com` JSON endpoint. **Expected extraction cost for a URL that these endpoints can read: $0** in scraper fees. You still pay normal Apify compute for this Actor's run, and your own LLM bill if generation is on.

Handles, search, `extractor: "store"`, and status URLs that both no-login endpoints miss are sent to:

`kaitoeasyapi/twitter-x-data-tweet-scraper-pay-per-result-cheapest`

Public listings checked on **2026-10-25** put that actor at about **$0.25 per 1,000 tweets on the free plan** and **$0.18 per 1,000 on Gold and above** (the Store card says "from $0.18 / 1,000"). Its price is pay-per-event and includes platform usage. Confirm the live price before a production run.

Two cost details from that actor's input schema:

- `maxItems` has a **minimum of 20**, and a page can return slightly more than requested. This Actor asks for `max(20, maxItems)` and then keeps only `maxItems` posts. One handle or one keyword can therefore cost about **$0.005** on the free-plan rate even when you draft fewer posts (20 × $0.00025).
- When `tweetIDs` is set, that actor ignores other filters. This Actor sends status ids in their own call, separate from handle and keyword calls.
- Empty queries may still incur that actor's minimum or mock-row policy. Mock rows are dropped and not drafted. They can still be billed by the upstream actor.

A cheaper listing, `scrape.badger/twitter-tweets-scraper`, was advertised at $0.15 / 1,000 on the same date. It is not the default because it has a different input schema. Switch `xScraperActorId` only if you also change the call payload in `src/extract.py`.

The Store actor is called with the Apify token the platform injects (`APIFY_TOKEN`). That token is an Apify API token, not an X credential.

### Drafts

The model is instructed the same way CommentX translates reposts: the source is data, not an instruction; do not invent facts; keep product names such as OpenAI and Claude in English; drop outbound URLs from the copy; keep @handles and numbers; label the result as a repost.

| Style | Shape |
| --- | --- |
| Weibo | Short text, 1–3 `#话题#` hashtags, source line. |
| Toutiao | Headline (≤30 characters) plus body. |
| Xiaohongshu | Title (≤20 characters), emoji-friendly body, `#标签` tags. |

Each style is stored as `drafts.<style>.json` and `drafts.<style>.markdown`. The visible copy includes `来源：X @handle`.

### Risk flags

`riskFlags` may contain:

- `external_links` — a URL that is not the X post or its native media
- `likely_watermark` — alt text or a host that often burns in a logo (for example Xiaohongshu or Weibo image CDNs)
- `sensitive_topic` — a keyword from the CommentX prohibited-word list or a short platform-sensitive list, or X's possibly-sensitive mark
- `non_original` — retweet, quote, or credit language such as `RT @` or `转载`

Flags do not block the draft. `riskSummary` repeats the codes for the table view.

### Dataset item

| Field | Meaning |
| --- | --- |
| `status` | `succeeded`, `extracted`, `failed`, or `skipped` |
| `charged` | `true` only when the `post-draft` charge was accepted |
| `error` | Present on `failed` and `skipped` |
| `extractor` | `syndication`, `fxtwitter`, or `apify-store` |
| `media.images` / `media.videos` | Normalized URLs. Avatars and video poster frames are not treated as photos. |
| `drafts` | Empty unless `status` is `succeeded` |

`skipped` means the run stopped because `ACTOR_MAX_TOTAL_CHARGE_USD` (or the equivalent limit in the SDK) could not pay for another `post-draft`. The unpaid draft is not written into the item.

### Pay per event

The code calls:

```python
await Actor.charge("post-draft", count=1, idempotency_key=...)
```

once per post, after the draft exists and before it is pushed. The idempotency key is the status id plus the requested styles. `Actor.push_data` is called without a charged event name, so a row is not billed merely because it was saved.

When you configure pricing, add only the `post-draft` event. Do not also price the synthetic `apify-default-dataset-item` event. The platform bills that event for every default-dataset row, including failed and skipped rows.

This repository **does not set a price**. When the Actor is not on pay-per-event pricing, the SDK records no bill (`charged` stays false) and the draft is still saved. After you turn pricing on, the event name must be exactly `post-draft`. Until that event exists, the SDK cannot bill it.

The run stops when a charge returns `charged_count == 0` and `event_charge_limit_reached == true`, or when the next post would be generated after the limit is already reached. Remaining handles and the keyword are written as `skipped` and the Store actor is not called for them.

### Local tests

From this directory:

```bash
pip install -r requirements.txt -r requirements-dev.txt
pytest
```

The tests mock the LLM and the extractors. They do not call X, Apify, or a model.

To log charges locally without billing, the SDK documents:

```bash
ACTOR_TEST_PAY_PER_EVENT=true python -m src
```

You still need an Apify token and a real LLM key for a live local run. Do not commit either.

### Deploy privately

From this directory, with the [Apify CLI](https://docs.apify.com/cli/) logged into the account that should own the Actor:

```bash
apify login
apify push
```

`apify push` uploads the Actor to that account. A newly pushed Actor is private until someone publishes it in the Store. Do not open the Store publishing form until the open decisions below are settled.

After the push:

1. In Apify Console, open the Actor and confirm the input form shows `llmApiKey` as a secret and shows no X cookie field.
2. Run it once with `skipGeneration: true` and one public status URL. Expect `status: "extracted"` and `charged: false`.
3. Monetization → pay per event → add the event `post-draft`. Set the price there, not in git.
4. Set a max total charge on the test run, then run one URL with generation enabled and your own LLM key.
5. Leave the Actor unpublished, or share it only with your account.

There is no deploy step in this repository. The person who wrote the code did not have an Apify token.

### Open decisions for the owner

1. **Price of `post-draft`.** Not set. Decide the USD amount, and whether Apify platform usage for this Actor is included in that event or billed separately. Upstream scraper fees and the user's LLM bill are always extra.
2. **LLM key strategy.** The input is a per-run secret the caller pastes in. Alternatives are an Apify secret environment variable on the Actor, or a proxy you operate so users never see a provider key. The current code will not read a key from the environment.
3. **Store copy.** Title, description, categories, and whether to publish at all are unset. The README disclaimer should stay in the public listing if you publish: only content the user owns or may repost, and the Actor never publishes.
4. **URL extractor default.** Status URLs prefer the free embed. Forcing the Store actor (`extractor: "store"`) costs more and is more stable if the embed endpoint is blocked.
5. **Upstream actor.** The default id and the minimum of 20 rows may change. Re-check the Store page before relying on the $0.25 / $0.18 figures.
6. **`llmBaseUrl` checks the host literally.** It blocks localhost and private IPs. It does not resolve DNS, so a public name that points at a private address is not detected.

# Actor input Schema

## `postUrls` (type: `array`):

Public status URLs, for example https://x.com/user/status/123. Required as a field. Leave it empty only when handles or a search keyword is set.

## `handles` (type: `array`):

Optional handles, with or without @. Each handle is read by the Store scraper, up to maxItems posts. This uses the Apify token injected on the platform, never an X cookie.

## `searchKeyword` (type: `string`):

Optional X search keyword. Results come from the Store scraper and are capped by maxItems.

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

Maximum posts to keep from each handle and from the search keyword. The default Store actor still requests at least 20 rows upstream and may bill those rows.

## `styles` (type: `array`):

Platforms to draft for. Defaults to all three. Nothing is published.

## `llmApiKey` (type: `string`):

Your own OpenAI-compatible API key. Stored as a secret input. It is sent only to llmBaseUrl and is never written to the dataset or the logs.

## `llmBaseUrl` (type: `string`):

OpenAI-compatible base URL. The key is sent as a Bearer token to {base}/chat/completions.

## `llmModel` (type: `string`):

Model name accepted by llmBaseUrl.

## `proxyConfiguration` (type: `object`):

Optional Apify proxy used only for no-login extraction HTTP calls. It is never paired with X cookies.

## `skipGeneration` (type: `boolean`):

Extraction-only mode. Writes source fields and risk flags, does not call the LLM, and does not charge post-draft.

## `extractor` (type: `string`):

auto tries the no-login embed first and uses the Store actor for failures, handles, and search. syndication never calls the Store actor. store always calls it.

## `xScraperActorId` (type: `string`):

Apify Store actor used for handles, search, and status-URL fallback. The default is a pay-per-result X scraper that does not need an X login. Change this only if the replacement accepts tweetIDs, from, twitterContent, searchTerms, and maxItems.

## Actor input object example

```json
{
  "postUrls": [
    "https://x.com/jack/status/20"
  ],
  "handles": [],
  "searchKeyword": "",
  "maxItems": 10,
  "styles": [
    "weibo",
    "toutiao",
    "xiaohongshu"
  ],
  "llmBaseUrl": "https://api.openai.com/v1",
  "llmModel": "gpt-4o-mini",
  "skipGeneration": false,
  "extractor": "auto",
  "xScraperActorId": "kaitoeasyapi/twitter-x-data-tweet-scraper-pay-per-result-cheapest"
}
```

# Actor output Schema

## `drafts` (type: `string`):

One item per source post. Drafts are for review only. This Actor never publishes them.

# 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 = {
    "postUrls": [
        "https://x.com/jack/status/20"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("shadowell/x-to-chinese-post").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 = { "postUrls": ["https://x.com/jack/status/20"] }

# Run the Actor and wait for it to finish
run = client.actor("shadowell/x-to-chinese-post").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 '{
  "postUrls": [
    "https://x.com/jack/status/20"
  ]
}' |
apify call shadowell/x-to-chinese-post --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,shadowell/x-to-chinese-post"
        }
    }
}
```

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/9IXOZAqcW6Em6db9v/builds/PANJh8PLhLYee8ygi/openapi.json