# Chinese AI Brand Visibility — Kimi, GLM, DeepSeek & Qwen (`zinin/chinese-ai-brand-visibility`) Actor

Measure whether and where a brand appears in grounded answers from four leading Chinese AI model families, with citations and no buyer API key.

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

## Pricing

from $34.00 / 1,000 grounded model observations

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 AI Brand Visibility — Kimi, GLM, DeepSeek & Qwen

See whether your brand appears, where it ranks, which competitors appear first, and which web pages support the answer across four Chinese AI model families. One run turns the same buyer-intent question into comparable, citation-bearing rows—without requiring your own model key.

![Four grounded AI answers become one comparable brand-visibility view](https://api.apify.com/v2/key-value-stores/3gM4tUNLcvTnZ50tV/records/store-hero.png)

### What you get

- **One comparable row per query and model.** Track Kimi, GLM, DeepSeek and Qwen against the same brand, market, language and buyer question.
- **Mention and position, not just raw prose.** Each grounded row records `mentioned`, a one-based `position`, the first detected competitor and the model's ordered brand list.
- **Inspectable web evidence.** `citedUrls`, `citedDomains`, `toolsUsed` and structured citation annotations stay with the answer they support.
- **Useful failures instead of silent gaps.** A model timeout, malformed response or ungrounded answer becomes a free `status: "error"` diagnostic row.
- **No buyer model API key.** This Actor pays its model dependency from the publisher account; buyers see only this Actor's published pay-per-event charges.

Use it for AI-search monitoring, GEO baselines, competitor share-of-answer research, market-by-market message testing, or a recurring Dataset feed for dashboards and alerts.

### Quick start

Open the public Task **Compare Nike visibility across Kimi, GLM, DeepSeek and Qwen** for a tested four-model example. Its buyer-friendly configuration asks one query, runs two models at a time, allows 300 seconds, and caps the total charge at **$0.18**.

To create your own run:

1. Enter the exact brand or product name you want to track.
2. Add up to ten known competitors if you want explicit competitor matching.
3. Add one to five unique buyer-intent questions.
4. Select one to four models, then choose the market and answer language.
5. Set a maximum total charge that covers the observations you want.
6. After a `SUCCEEDED` run, open the default Dataset and filter `status` to `grounded` or `error`.

```json
{
  "brand": "Nike",
  "competitors": ["Adidas", "New Balance", "On"],
  "queries": [
    "Which sustainable running shoe brands should a US buyer compare?"
  ],
  "models": [
    "moonshotai/kimi-k2.6",
    "z-ai/glm-4.6",
    "deepseek/deepseek-chat-v3.1",
    "qwen/qwen3-30b-a3b"
  ],
  "market": "United States",
  "language": "English",
  "maxModelConcurrency": 2
}
```

### Input

| Field | Required | Limits | What it controls |
| --- | --- | --- | --- |
| `brand` | yes | 1–100 characters | Exact brand, company or product name matched in the structured brand order and answer. |
| `queries` | yes | 1–5 unique strings, 3–300 characters each | Buyer questions. Every query runs once against every selected model. |
| `competitors` | no | up to 10 unique names | Known competitor labels. They do not alter the model list or suppress other detected brands. |
| `models` | no | 1–4 fixed IDs | Kimi K2.6, GLM 4.6, DeepSeek V3.1 and Qwen3 30B A3B; all four are selected by default. |
| `market` | no | 2–80 characters | Country or region used as buyer context; defaults to `United States`. |
| `language` | no | 2–40 characters | Natural-language answer name; defaults to `English`. |
| `maxModelConcurrency` | no | `1` or `2` | Number of child model batches run in parallel; defaults to `2`. |

Maximum potential observations are `unique queries × selected models`, up to **20**. Duplicate list values are normalized away, unsupported model IDs and unknown fields are rejected, and arbitrary model/provider configuration is not accepted.

### How grounding and ranking work

For each model, the Actor sends the same neutral market-research prompt to the public paid dependency `fayoussef/bulk-llm-runner` (immutable Actor ID `0pArcqOZFSjoCBlJX`). The dependency is required to use web search and return a JSON object containing a bounded answer plus brands in first-mention order.

A row is `grounded` only when all of these are present:

1. the dependency run succeeds;
2. the response is a complete parseable object with a non-empty ordered brand list;
3. the dependency reports the `web_search` tool; and
4. at least one structured HTTP(S) URL citation is attached.

`mentioned` uses normalized whole-token brand matching. `position` is the brand's one-based index in `brandsMentioned`, or `null` when the brand is absent from that list. `competitor` is the first known competitor in the ordered list; when none of the supplied competitors match, it is the first other brand returned by the model.

![Only complete web-searched, ranked and cited answers reach paid Dataset delivery](https://api.apify.com/v2/key-value-stores/3gM4tUNLcvTnZ50tV/records/store-evidence-flow.png)

### Output

The default Dataset contains both paid grounded observations and free diagnostic rows. This abbreviated example is from a successful four-model public Task run:

```json
{
  "schemaVersion": "1.0",
  "status": "grounded",
  "brand": "Nike",
  "competitor": "On",
  "query": "Which sustainable running shoe brands should a US buyer compare?",
  "modelFamily": "Kimi",
  "modelId": "moonshotai/kimi-k2.6",
  "market": "United States",
  "language": "English",
  "mentioned": true,
  "position": 4,
  "citedDomains": [
    "thegoodtrade.com",
    "theenvironmentalblog.org",
    "goodonyou.eco",
    "growthscribe.com",
    "shopback.com"
  ],
  "groundingStatus": "dependency-web-search",
  "sourceActorId": "0pArcqOZFSjoCBlJX",
  "sourceRunId": "P7S2vPPH4IkvWUMXU",
  "error": null
}
```

Each grounded row also includes a bounded `answerSnippet`, full structured `citedUrls`, `checkedAt`, the dependency Dataset ID, reported token/cost metadata, and an `evidence` object with the bounded answer, ordered brands, matched known competitors, tools and citations.

Each error row keeps the requested brand, query, model, market and language, but sets `groundingStatus` to `ungrounded`, leaves rank and evidence empty, and carries a bounded redacted `error`. Do not count error rows as negative brand findings.

The run's key-value store record `OUTPUT` summarizes requested, attempted, grounded, delivered, billed and error counts plus dependency run IDs. Child accounting in that record is a pre-exit observation; terminal platform cost is authoritative only after the run finishes.

### Pricing and charge safety

This Actor uses pay per event. Apify charges `apify-actor-start` automatically (one event per GB of configured memory, minimum one); the public 256 MB Task therefore incurs one start event. The Actor emits one `result-found` only for each complete grounded observation delivered through the paid Dataset write. Error diagnostics, ungrounded responses and work withheld for insufficient buyer budget do **not** emit `result-found`.

| Tier | Start | Grounded observation | Discount |
| --- | ---: | ---: | ---: |
| FREE | $0.0050 | $0.0400 | 0% |
| BRONZE | $0.00475 | $0.0380 | 5% |
| SILVER | $0.00450 | $0.0360 | 10% |
| GOLD | $0.00425 | $0.0340 | 15% |
| PLATINUM | $0.00410 | $0.0328 | 18% |
| DIAMOND | $0.00400 | $0.0320 | 20% |

At FREE pricing, the four-model public Task costs at most **$0.165**: `$0.005 + (4 × $0.040)`. A maximum 5-query × 4-model run costs at most **$0.805** at the same tier and 256 MB. If the remaining buyer cap cannot cover all requested observations, the Actor starts only the affordable prefix and reports `partial_budget`; it does not perform knowingly unbillable model work.

The dependency's PPE and platform usage are charged separately to the publisher account and are already part of this product's economics. They are not charged again to the buyer.

### API and automation

Run the public Task by ID and wait for completion:

```bash
curl -X POST \
  'https://api.apify.com/v2/actor-tasks/9PfJ2Xy346Mg1cd62/runs?token=APIFY_TOKEN&waitForFinish=300' \
  -H 'Content-Type: application/json' \
  --data-binary @input.json
```

Read `defaultDatasetId` from the terminal run, then request `/v2/datasets/DATASET_ID/items?clean=true`. In Make, n8n or another orchestrator, branch on terminal run status first, then branch each row on `status`; never turn a failed run or error row into a “not mentioned” result.

### Data handling and security boundary

Apify stores the original INPUT in the run key-value store, observations in the default Dataset and the run summary in `OUTPUT`, subject to your account's access and retention settings. Brand names, competitors, questions, market and language are sent to the dependency and its configured model/search providers. Submit public, non-sensitive research prompts only—never credentials, personal data, private strategy or confidential text.

The prompt tells the model to treat retrieved content as data rather than instructions, input fields reject control characters, error text is bounded and known tokens are redacted, and the Actor runs with `LIMITED_PERMISSIONS`. These controls reduce risk but cannot make third-party web content or model output trustworthy by themselves.

### Limits and interpretation

- “Grounded” means the dependency reported web search and at least one structured URL citation. It does **not** prove that every sentence is supported, current or correct.
- Model answers are stochastic and can change between runs even with identical input. Use repeated runs and timestamps for trend analysis.
- A one-based `position` reflects the model's returned first-mention order, not market share, sales rank, sentiment or recommendation quality.
- Citation availability and quality depend on the model, search provider and live web. Open and assess the cited pages before making a decision.
- The Actor does not crawl cited pages independently, fact-check claims, translate sources, infer missing observations, retry failed model calls, or switch to fallback models.
- Model IDs and upstream provider availability can change; a visible free diagnostic is the expected outcome when a fixed model cannot complete safely.

### FAQ

**Do I need an OpenRouter or model-provider key?** No. The publisher-owned dependency handles model access.

**Why can a successful run contain an error row?** The parent Actor can finish after delivering the models that passed while preserving a free diagnostic for a model that timed out, returned malformed JSON or lacked structured web citations.

**Is `mentioned: false` the same as an error?** No. It is meaningful only on a `grounded` row. An error row means no valid observation was made.

**Can I use Chinese or another answer language?** Yes. Supply a natural-language name in `language`; brand matching uses Unicode-aware normalization, but you should inspect aliases and translations that differ from your exact tracked name.

**Can I add another model?** Not in this version. The four model IDs are fixed so runs stay comparable and costs remain bounded.

**Can I schedule it?** Yes. Schedule the public Task or your own saved configuration, preserve `checkedAt`, and compare rows by query and `modelId` over time.

# Actor input Schema

## `brand` (type: `string`):

Exact brand, product or company name to find in each answer.

## `competitors` (type: `array`):

Used only to label competitors found in the answer; the Actor still preserves every named brand in evidence.

## `queries` (type: `array`):

Each unique query runs once against every selected model. Maximum billable observations = 5 × 4 = 20.

## `models` (type: `array`):

Every selected model creates one potential paid observation per query. Model IDs are fixed and cannot be overridden.

## `market` (type: `string`):

Country or region whose buyer context the answer should reflect.

## `language` (type: `string`):

Natural-language name such as English, Chinese, Russian or Georgian.

## `maxModelConcurrency` (type: `integer`):

One or two child model batches at a time. Two is the tested balance of speed and spend visibility.

## Actor input object example

```json
{
  "brand": "Nike",
  "competitors": [
    "Adidas",
    "New Balance",
    "On"
  ],
  "queries": [
    "Which sustainable running shoe brands should a US buyer compare?"
  ],
  "models": [
    "moonshotai/kimi-k2.6",
    "z-ai/glm-4.6",
    "deepseek/deepseek-chat-v3.1",
    "qwen/qwen3-30b-a3b"
  ],
  "market": "United States",
  "language": "English",
  "maxModelConcurrency": 2
}
```

# Actor output Schema

## `results` (type: `string`):

API URL for grounded observations and free diagnostics in the default Dataset.

## `OUTPUT` (type: `string`):

API URL for counts, dependency runs, billable deliveries and child COGS observed before Actor exit. Final child and parent COGS require post-run Apify API reads.

# 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 = {
    "brand": "Nike",
    "competitors": [
        "Adidas",
        "New Balance",
        "On"
    ],
    "queries": [
        "Which sustainable running shoe brands should a US buyer compare?"
    ],
    "models": [
        "moonshotai/kimi-k2.6",
        "z-ai/glm-4.6",
        "deepseek/deepseek-chat-v3.1",
        "qwen/qwen3-30b-a3b"
    ],
    "market": "United States",
    "language": "English",
    "maxModelConcurrency": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("zinin/chinese-ai-brand-visibility").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 = {
    "brand": "Nike",
    "competitors": [
        "Adidas",
        "New Balance",
        "On",
    ],
    "queries": ["Which sustainable running shoe brands should a US buyer compare?"],
    "models": [
        "moonshotai/kimi-k2.6",
        "z-ai/glm-4.6",
        "deepseek/deepseek-chat-v3.1",
        "qwen/qwen3-30b-a3b",
    ],
    "market": "United States",
    "language": "English",
    "maxModelConcurrency": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("zinin/chinese-ai-brand-visibility").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 '{
  "brand": "Nike",
  "competitors": [
    "Adidas",
    "New Balance",
    "On"
  ],
  "queries": [
    "Which sustainable running shoe brands should a US buyer compare?"
  ],
  "models": [
    "moonshotai/kimi-k2.6",
    "z-ai/glm-4.6",
    "deepseek/deepseek-chat-v3.1",
    "qwen/qwen3-30b-a3b"
  ],
  "market": "United States",
  "language": "English",
  "maxModelConcurrency": 2
}' |
apify call zinin/chinese-ai-brand-visibility --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zinin/chinese-ai-brand-visibility"
        }
    }
}

```

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/8YbRy3W9c9dYCYGOU/builds/dBx4ogbkTOWiGlr8E/openapi.json