# TikTok Keywords Discovery Tool (`maximedupre/tiktok-keywords-discovery-tool`) Actor

Discover TikTok autocomplete keyword suggestions from seed terms. Export source-ranked suggestions, types, language and region hints, and scrape timestamps to CSV, JSON, Excel, API, or integrations.

- **URL**: https://apify.com/maximedupre/tiktok-keywords-discovery-tool.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Social media, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.65 / 1,000 tiktok suggestions

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### 🔎 TikTok keywords discovery tool for autocomplete suggestions

TikTok Keywords Discovery Tool collects autocomplete keyword suggestions from [TikTok](https://www.tiktok.com/) search. Add one or more seed terms such as `gift ideas`, `skincare routine`, or `fitness meals`, then export source-ranked TikTok keyword suggestions with the original seed, suggestion text, type, language and region hints, and scrape timestamps.

Use this Actor for TikTok keyword research, content planning, social search research, TikTok SEO briefs, campaign ideation, and repeatable keyword exports. It helps you turn manual TikTok search-box checks into a structured Apify dataset you can download as JSON, CSV, Excel, XML, RSS, or HTML, or send to an API, webhook, scheduler, or integration.

For a small first run, keep the prefilled seeds `gift ideas` and `skincare routine`. The default run is intentionally small, so you can inspect the row shape before adding a larger keyword list.

### ✅ What this Actor does

- Searches TikTok autocomplete with one or more seed keywords.
- Saves one dataset item per keyword suggestion.
- Keeps TikTok's source order by default.
- Can sort suggestions alphabetically within each seed keyword.
- Can remove duplicate suggestions across the run.
- Adds the original seed keyword and seed position to every row.
- Adds suggestion type, normalized suggestion text, language, region, and scrape time.
- Stops at your per-keyword and total result limits.
- Runs without TikTok login, cookies, or a user-provided API key.

This Actor is focused on TikTok search autocomplete suggestions. It does not scrape TikTok videos, profiles, comments, followers, ads, TikTok Shop products, or search-volume metrics.

### 📦 Data you can extract

Each output item represents one TikTok autocomplete suggestion. Fields include:

- `seedKeyword` and `seedKeywordIndex`
- `suggestion` and `normalizedSuggestion`
- `suggestionType`
- `rank`
- `dedupeKey`
- `sourcePlatform` and `sourceSurface`
- `sourceQuery`
- `language` and `region`
- `scrapedAt`

The `rank` field reflects the order used in the output. With the default source ordering, it follows the order TikTok returned for that seed keyword. With alphabetical ordering, ranks are reassigned after sorting.

### 🚀 Common use cases

- Build TikTok keyword research exports for content planning.
- Find autocomplete phrases around a product, niche, creator topic, or audience problem.
- Compare related TikTok search suggestions across several seed terms.
- Create content calendars from phrases people may type into TikTok search.
- Feed TikTok keyword suggestions into spreadsheets, dashboards, or AI workflows.
- Schedule repeat checks for the same keyword set.
- Collect clean source-ranked suggestions for social search and TikTok SEO research.

### ▶️ How to run it

1. Add one or more seed keywords in **Seed keywords**.
2. Keep **Suggestions per keyword** at `25` for a quick first run.
3. Set **Total suggestion limit** if you want a hard cap across the whole run.
4. Choose TikTok source order or alphabetical order.
5. Choose whether to remove duplicate suggestions.
6. Start the Actor and open the dataset.

For larger jobs, add several related seeds and use the total limit to keep the run size predictable.

### 🛠️ Input

#### 🧪 Example input

```json
{
	"keywords": ["gift ideas", "skincare routine"],
	"maxSuggestionsPerKeyword": 25,
	"maxTotalResults": 100,
	"resultOrder": "source",
	"deduplicateSuggestions": true,
	"includeSeedEcho": true,
	"language": "en",
	"region": "US"
}
````

#### 🎯 Seed keywords

Enter plain TikTok search seeds. Good examples:

- `gift ideas`
- `skincare routine`
- `fitness meals`
- `home office`
- `summer outfits`

Each seed is queried separately. Empty and duplicate seed values are ignored during normalization.

#### 📏 Limits

Use `maxSuggestionsPerKeyword` to control how many suggestions can be saved for each seed. Use `maxTotalResults` when you want a hard cap across the whole run.

#### 🧹 Sorting and cleanup

`resultOrder` can keep TikTok's source order or sort suggestions alphabetically. `deduplicateSuggestions` removes repeated normalized suggestions across all seeds. `includeSeedEcho` controls whether to keep a suggestion when TikTok returns the same text as the seed keyword.

#### 🌍 Localization

`language` and `region` are hints for the TikTok search surface. TikTok may still return suggestions that mix languages or local interests, depending on what it currently shows for the seed.

### 📊 Output example

```json
{
	"seedKeyword": "gift ideas",
	"seedKeywordIndex": 1,
	"suggestion": "gift ideas for mom",
	"normalizedSuggestion": "gift ideas for mom",
	"suggestionType": "suggestion",
	"rank": 1,
	"dedupeKey": "gift ideas for mom",
	"sourcePlatform": "tiktok",
	"sourceSurface": "search_autocomplete",
	"sourceQuery": "gift ideas",
	"language": "en",
	"region": "US",
	"scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each TikTok keyword suggestion that is found and saved. The default input is small enough for a low-cost test run.

### ⚠️ Limits and caveats

- TikTok autocomplete can change over time and by region.
- Some seeds can return fewer suggestions than your requested limit.
- The Actor does not provide search volume, CPC, popularity scores, or trend predictions.
- Language and region are source hints, not guaranteed filters.
- TikTok may temporarily return fewer suggestions or no suggestions for a seed.

### ❓ FAQ

#### 🔐 Does this use the official TikTok API?

No. It collects public TikTok autocomplete suggestions shown by TikTok search. You do not need to provide a TikTok account, cookies, or API key.

#### 🎬 Can it scrape TikTok videos or profiles?

No. This Actor is only for TikTok keyword suggestions. Use a TikTok video, profile, transcript, or comments scraper when you need content rows instead of keyword ideas.

#### 📈 Does it return search volume?

No. The output contains suggestions and source order, not search-volume or popularity metrics. This avoids inventing metrics that TikTok does not expose through this search surface.

#### 🧺 Can I run many keywords at once?

Yes. Add multiple seed keywords and use the per-keyword and total limits to control the run size.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~tiktok-keywords-discovery-tool/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [TikTok Transcript Scraper ↗](https://apify.com/maximedupre/tiktok-transcript-scraper) - Extract transcript text and subtitle rows from public TikTok video URLs.
- [Twitter Scraper ↗](https://apify.com/maximedupre/twitter-scraper) - Search public X/Twitter posts or export current trends for a region.
- [YouTube Channel Scraper ↗](https://apify.com/maximedupre/youtube-channel-scraper) - Export public YouTube channel profiles and recent video rows.
- [Google Shopping Ads Scraper ↗](https://apify.com/maximedupre/google-shopping-ads-scraper) - Collect paid Google Shopping ad products for keyword research.
- [Quora Search Scraper ↗](https://apify.com/maximedupre/quora-search-scraper) - Find public Quora question pages from search terms or direct URLs.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `keywords` (type: `array`):

Enter one or more TikTok search seeds such as gift ideas, skincare routine, or fitness meals. Each seed is checked separately.

## `maxSuggestionsPerKeyword` (type: `integer`):

Maximum TikTok autocomplete suggestions to save for each seed keyword. Keep 25 for a small first run.

## `maxTotalResults` (type: `integer`):

Maximum TikTok keyword suggestions to save across the whole run.

## `resultOrder` (type: `string`):

Keep TikTok's source order for each seed keyword, or sort each seed keyword's suggestions alphabetically.

## `deduplicateSuggestions` (type: `boolean`):

Save each normalized TikTok suggestion only once across the run.

## `includeSeedEcho` (type: `boolean`):

Keep suggestions even when TikTok returns the exact seed keyword text.

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

Preferred TikTok interface language for autocomplete suggestions.

## `region` (type: `string`):

Preferred TikTok region hint for autocomplete suggestions. Use a two-letter country code such as US, GB, DE, or JP.

## Actor input object example

```json
{
  "keywords": [
    "gift ideas",
    "skincare routine"
  ],
  "maxSuggestionsPerKeyword": 25,
  "maxTotalResults": 100,
  "resultOrder": "source",
  "deduplicateSuggestions": true,
  "includeSeedEcho": true,
  "language": "en",
  "region": "US"
}
```

# Actor output Schema

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

Open the dataset with one item per TikTok autocomplete suggestion.

# 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 = {
    "keywords": [
        "gift ideas",
        "skincare routine"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/tiktok-keywords-discovery-tool").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 = { "keywords": [
        "gift ideas",
        "skincare routine",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/tiktok-keywords-discovery-tool").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "gift ideas",
    "skincare routine"
  ]
}' |
apify call maximedupre/tiktok-keywords-discovery-tool --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/tiktok-keywords-discovery-tool",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Keywords Discovery Tool",
        "description": "Discover TikTok autocomplete keyword suggestions from seed terms. Export source-ranked suggestions, types, language and region hints, and scrape timestamps to CSV, JSON, Excel, API, or integrations.",
        "version": "0.1",
        "x-build-id": "kWs1bZCT7pvaqZQbb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~tiktok-keywords-discovery-tool/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-tiktok-keywords-discovery-tool",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/maximedupre~tiktok-keywords-discovery-tool/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-tiktok-keywords-discovery-tool",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/maximedupre~tiktok-keywords-discovery-tool/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-tiktok-keywords-discovery-tool",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Seed keywords",
                        "minItems": 1,
                        "maxItems": 500,
                        "type": "array",
                        "description": "Enter one or more TikTok search seeds such as gift ideas, skincare routine, or fitness meals. Each seed is checked separately.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxSuggestionsPerKeyword": {
                        "title": "Suggestions per seed",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum TikTok autocomplete suggestions to save for each seed keyword. Keep 25 for a small first run.",
                        "default": 25
                    },
                    "maxTotalResults": {
                        "title": "Total suggestions",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum TikTok keyword suggestions to save across the whole run.",
                        "default": 100
                    },
                    "resultOrder": {
                        "title": "Suggestion order",
                        "enum": [
                            "source",
                            "alphabetical"
                        ],
                        "type": "string",
                        "description": "Keep TikTok's source order for each seed keyword, or sort each seed keyword's suggestions alphabetically.",
                        "default": "source"
                    },
                    "deduplicateSuggestions": {
                        "title": "Remove duplicate suggestions",
                        "type": "boolean",
                        "description": "Save each normalized TikTok suggestion only once across the run.",
                        "default": true
                    },
                    "includeSeedEcho": {
                        "title": "Keep seed echoes",
                        "type": "boolean",
                        "description": "Keep suggestions even when TikTok returns the exact seed keyword text.",
                        "default": true
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "tr",
                            "id",
                            "ja",
                            "ko"
                        ],
                        "type": "string",
                        "description": "Preferred TikTok interface language for autocomplete suggestions.",
                        "default": "en"
                    },
                    "region": {
                        "title": "Region",
                        "minLength": 2,
                        "maxLength": 2,
                        "type": "string",
                        "description": "Preferred TikTok region hint for autocomplete suggestions. Use a two-letter country code such as US, GB, DE, or JP.",
                        "default": "US"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```