# China-AI-Pricing-FreeTier-Tracker (`peppy_socket_yxw/china-ai-pricing-freetier-tracker`) Actor

Track Chinese AI providers: pricing (even FREE), 4 types of free models, deals & price changes. Covers DeepSeek, Qwen, GLM, Kimi, MiniMax, Doubao, ERNIE, Hunyuan, Baichuan, Yi, SiliconFlow. Machine-readable JSON, daily change detection.

- **URL**: https://apify.com/peppy\_socket\_yxw/china-ai-pricing-freetier-tracker.md
- **Developed by:** [Chance](https://apify.com/peppy_socket_yxw) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / run\_base

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

### What does China AI Pricing & Free Tier Tracker do?

**China AI Pricing & Free Tier Tracker** is an [Apify Actor](https://apify.com/actors) that continuously monitors **11 major Chinese AI providers** and delivers structured, machine-readable data on API pricing, **free tiers**, promotions, and price changes.

Instead of manually checking dozens of Chinese AI pricing pages, you get **structured datasets** updated on your schedule — ready for cost optimization, model routing, AI FinOps, or building your own pricing dashboard.

**Providers covered**: DeepSeek, Alibaba/Qwen, Zhipu AI/GLM, Moonshot/Kimi, Baidu/ERNIE, MiniMax, ByteDance/Doubao, Tencent/Hunyuan, Baichuan, 01.AI/Yi, SiliconFlow

**Key feature**: This Actor tracks **4 types of free models** — permanently free, limited-time free, public beta, and trial credits — with confidence levels and change detection.

### Why use this Actor?

- **Save hours of manual research** — Chinese AI pricing is fragmented across 10+ platforms, all in Chinese
- **Track free tiers** — find which models offer free quotas and how much
- **Never miss a deal** — promotions, discounts, and limited-time offers are captured automatically
- **Detect price changes** — scheduled runs compare against historical snapshots and flag changes
- **Machine-readable JSON** — structured output ready for n8n, Make, Python, JavaScript, AI Agents
- **Source provenance** — every price has a source URL, check timestamp, and confidence level

#### Use cases

| Use case | What you get |
|----------|-------------|
| **AI cost optimization** | Compare actual API costs across all Chinese providers |
| **Model routing** | Input pricing data into your AI Gateway / Model Router |
| **FinOps monitoring** | Scheduled runs detect price drops and increases |
| **Free tier discovery** | Find models with free quotas for development/testing |
| **Deal tracking** | Get notified when your preferred model goes on sale |

### How to use

1. **Run the Actor** on [Apify Console](https://console.apify.com) or via API
2. **Choose providers**: `["all"]` or specific ones like `["deepseek", "qwen"]`
3. **Select data**: toggle pricing, free tiers, deals, and price changes
4. **View results** in the Output tab or download as JSON/CSV/Excel

#### Quick start via API

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~china-ai-pricing-freetier-tracker/runs" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "providers": ["all"],
    "include_pricing": true,
    "include_free_tiers": true,
    "include_deals": true,
    "include_changes": true
  }'
```

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `providers` | string\[] | `["all"]` | Providers to collect (or `"all"`) |
| `include_pricing` | boolean | `true` | Collect API pricing data (**free**) |
| `include_free_tiers` | boolean | `true` | Collect free tier/quota info ($1.00/run) |
| `include_deals` | boolean | `true` | Collect promotions and discounts ($0.60/run) |
| `include_changes` | boolean | `true` | Detect price changes since last run ($0.40/run) |
| `only_active_deals` | boolean | `true` | Only include currently active deals |

**Default run (no input)**: collects all data types from all providers. Premium charges: $1.00 + $0.60 + $0.40 = **$2.00/run**. To run free only, set `include_free_tiers`, `include_deals`, and `include_changes` to `false`.

### Output

#### Datasets

The Actor outputs data to **5 named datasets** plus a **default dataset**:

| Dataset | Description | Price |
|---------|-------------|-------|
| `pricing` | Current API pricing (original + normalized to USD) | Free |
| `free-tiers` | Free quotas and free models | $1.00/run |
| `deals` | Active promotions and discounts | $0.60/run |
| `changes` | Price changes detected since last run | $0.40/run |
| Default dataset | Summary of all records (for Console Output tab) | — |

All datasets have source fields flattened as scalars: `source_type`, `source_url`, `source_checked_at`, `source_confidence`, `source_effective_from`.

#### Example: Pricing record

```json
{
  "_type": "pricing",
  "provider_id": "deepseek",
  "model_id": "deepseek-v4-flash",
  "original_currency": "CNY",
  "original_unit": "per_1m_tokens",
  "original_input_price": 3.0,
  "original_output_price": 9.0,
  "input_price": 0.414,
  "output_price": 1.242,
  "cached_input_price": 0.0138,
  "batch_input_price": 0.207,
  "batch_output_price": 0.621,
  "currency": "USD",
  "price_unit": "per_1m_tokens",
  "context_window": 1000000,
  "source_type": "official",
  "source_url": "https://api-docs.deepseek.com/zh-cn/quick_start/pricing",
  "source_checked_at": "2026-09-14T10:45:58.589Z",
  "source_confidence": "high"
}
```

#### Example: Free tier record

```json
{
  "_type": "free_tier",
  "provider_id": "tencent",
  "model_id": "hunyuan-a13b",
  "free": true,
  "free_type": "permanently_free",
  "free_amount": null,
  "free_unit": null,
  "period": "lifetime",
  "conditions": null,
  "expires_at": null,
  "source_type": "official",
  "source_url": "https://cloud.tencent.com/document/product/1729/97731",
  "source_confidence": "high"
}
```

#### Example: Price change record

```json
{
  "_type": "change",
  "provider_id": "deepseek",
  "model_id": "deepseek-v4-flash",
  "change_type": "price_decrease",
  "field": "input_price",
  "old_value": 0.552,
  "new_value": 0.414,
  "change_percent": -25,
  "anomaly": false,
  "detected_at": "2026-09-14T10:00:00Z",
  "source_type": "official",
  "source_url": "actor://change-detector"
}
```

### Key-Value Store outputs

| Key | Description |
|-----|-------------|
| `run-summary` | Run stats: model count, provider count, duration, per-provider status |
| `provider-status` | Per-provider collection result (success/failed, records found, duration) |
| `price-changes-history` | All detected changes across all runs |
| `latest-snapshot` | Current data snapshot for next-run comparison |

### Data fields reference

#### Pricing

| Field | Description |
|-------|-------------|
| `original_input_price` | Price as shown on the provider's website |
| `original_currency` | Original currency (CNY, USD) |
| `original_unit` | Original unit (per\_1m\_tokens, per\_1k\_tokens) |
| `input_price` | Normalized input price (USD per 1M tokens) |
| `output_price` | Normalized output price (USD per 1M tokens) |
| `cached_input_price` | Cached/buffered input price (if available) |
| `batch_input_price` | Batch/off-peak input price (if available) |
| `batch_output_price` | Batch/off-peak output price (if available) |
| `source_url` | URL where the price was found |
| `source_checked_at` | When the price was last checked |
| `source_confidence` | Data confidence (high/medium/low) |

#### Free tiers

| Field | Description |
|-------|-------------|
| `free_type` | Type: permanently\_free, limited\_time\_free, public\_beta\_free, trial\_credit, free\_model, token\_quota, daily\_quota, monthly\_quota, new\_user\_credit, free\_requests |
| `free_amount` | Amount of free usage (e.g., 1000000 tokens) |
| `free_unit` | Unit: tokens, requests |
| `period` | Period: daily, monthly, one\_time, lifetime |
| `conditions` | Conditions: "new users only", "first 14 days", etc. |
| `region_limit` | Region restriction (if any) |
| `rate_limit` | Rate limit (e.g., "QPS=2") |

#### Deals

| Field | Description |
|-------|-------------|
| `deal_type` | Type: discount, free\_quota, limited\_time\_price, batch\_discount, campaign |
| `original_price` | Price before discount |
| `discount_price` | Price during deal |
| `discount_percent` | Discount percentage |
| `expires_at` | When the deal expires (null if no expiry) |

### Scheduled monitoring

Set up a cron schedule to track changes automatically:

| Frequency | Purpose |
|-----------|---------|
| Every 6 hours | Track fast-changing prices and new deals |
| Daily | Standard monitoring for most use cases |
| Weekly | Low-frequency overview |

Use [Apify Scheduler](https://docs.apify.com/platform/schedules) or trigger via webhook.

### Pricing

#### PPE charges (per-event)

| Dataset | Price | Content |
|---------|-------|---------|
| **`pricing`** | **Free** | All model prices (input/output/cached/batch) |
| **`free-tiers`** | **$1.00/run** | 4 types of free models with confidence levels |
| **`deals`** | **$0.60/run** | Active promotions + Free Tier Deathwatch |
| **`changes`** | **$0.40/run** | Price changes since last run + anomaly detection |

**Default run (all enabled)**: $1.00 + $0.60 + $0.40 = **$2.00/run**

To run free only: set `include_free_tiers`, `include_deals`, and `include_changes` to `false` in Input.

#### Platform costs (paid by you, from your Apify plan)

| Mode | Approximate time | Compute Units |
|------|-----------------|---------------|
| All providers | ~2-4 minutes | ~0.1-0.2 CU |
| Single provider | ~10-30 seconds | ~0.01-0.03 CU |

On Apify's free tier ($5/month), you can run the free pricing dataset daily (~50 runs/month). Premium datasets require a paid Apify plan.

### Tips

- **Start with `["all"]`** to see what data is available, then filter to specific providers
- **Enable `include_changes`** to detect price drops — this is the most valuable long-term feature
- **Use the `changes` dataset** with webhooks to get Slack/email notifications on price changes
- **Check `provider-status`** in KVS to see which providers succeeded or failed
- **Use `anomaly: true`** in changes to filter out suspicious >90% changes (likely parsing errors)
- **Run free only**: set `include_free_tiers`, `include_deals`, `include_changes` all to `false`

### Data quality

- Every record includes `source_url` — you can always verify the data
- Every record includes `source_confidence` — high/medium/low based on source type
- Prices that cannot be determined are set to `null`, never guessed
- Anomalous price changes (>90%) are flagged with `anomaly: true`
- Single provider failures don't crash the entire Actor
- Providers are run with error isolation — one failure doesn't affect others

### FAQ

**Q: How accurate is the pricing data?**
A: Prices come from official provider websites and documentation. Each record includes the source URL and check timestamp. We never guess prices — if a price can't be determined, it's set to null.

**Q: How often should I run this Actor?**
A: Daily is sufficient for most use cases. Run every 6 hours if you need to catch fast-changing promotions.

**Q: What happens when a provider website changes?**
A: Each provider runs in isolation. If one provider's website changes, only that provider fails — all others continue working. Check `provider-status` in KVS for failure details.

**Q: Can I get notified of price changes?**
A: Yes. Set up an Apify Webhook on the Actor's "Succeeded" event. The `changes` dataset will contain all detected price changes.

**Q: Why are some prices null?**
A: We set prices to null when the source website doesn't clearly state the price, or when the page can't be parsed. We never guess or infer prices from other models.

**Q: What is the default run cost?**
A: With all defaults (no input), the Actor collects pricing (free) + free tiers ($1.00) + deals ($0.60) + changes ($0.40) = $2.00 per run. To run for free, disable the three premium datasets in Input.

### Support

- [Apify Discord](https://discord.com/invite/apify) — community support
- Contact the author for feature requests and custom solutions

***

Built for developers who need to track Chinese AI API costs programmatically.

# Actor input Schema

## `providers` (type: `array`):

Which providers to collect. Use 'all' for everyone, or select specific ones.

## `include_pricing` (type: `boolean`):

Collect current API pricing data for all models. This dataset is FREE to access.

## `include_free_tiers` (type: `boolean`):

4 types: permanently free, limited-time free, public beta, trial credits. Includes confidence levels and region limits.

## `include_deals` (type: `boolean`):

Current promotions, discounts, and Free Tier Deathwatch (discontinued free models).

## `include_changes` (type: `boolean`):

Detect price changes since last run, with anomaly flagging for >90% changes.

## `only_active_deals` (type: `boolean`):

Only include deals that are currently active (not expired).

## Actor input object example

```json
{
  "providers": [
    "all",
    "deepseek",
    "qwen",
    "zhipu",
    "moonshot",
    "baidu",
    "minimax",
    "doubao",
    "tencent",
    "baichuan",
    "yi",
    "siliconflow"
  ],
  "include_pricing": true,
  "include_free_tiers": true,
  "include_deals": true,
  "include_changes": true,
  "only_active_deals": true
}
```

# Actor output Schema

## `dataset` (type: `string`):

Summary of all records (models, pricing, free tiers, deals, changes).

## `key_value_store` (type: `string`):

Run statistics, provider statuses, and historical change data.

# 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 = {
    "providers": [
        "all",
        "deepseek",
        "qwen",
        "zhipu",
        "moonshot",
        "baidu",
        "minimax",
        "doubao",
        "tencent",
        "baichuan",
        "yi",
        "siliconflow"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("peppy_socket_yxw/china-ai-pricing-freetier-tracker").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 = { "providers": [
        "all",
        "deepseek",
        "qwen",
        "zhipu",
        "moonshot",
        "baidu",
        "minimax",
        "doubao",
        "tencent",
        "baichuan",
        "yi",
        "siliconflow",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("peppy_socket_yxw/china-ai-pricing-freetier-tracker").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 '{
  "providers": [
    "all",
    "deepseek",
    "qwen",
    "zhipu",
    "moonshot",
    "baidu",
    "minimax",
    "doubao",
    "tencent",
    "baichuan",
    "yi",
    "siliconflow"
  ]
}' |
apify call peppy_socket_yxw/china-ai-pricing-freetier-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,peppy_socket_yxw/china-ai-pricing-freetier-tracker"
        }
    }
}
```

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/ioAaNoOrMeff3UTog/builds/PgAaRqOPcecPDOmOd/openapi.json