# TikTok Latest Posts Monitor (`simple.actors/tiktok-profile-posts`) Actor

Check any public TikTok profile for its latest posts: caption, hashtags, views, likes, comments, shares, video files, photo carousels and the full account record. No login, no cookies, no API key. Built for polling many accounts often rather than deep history: up to 13 posts per profile. Unofficial.

- **URL**: https://apify.com/simple.actors/tiktok-profile-posts.md
- **Developed by:** [Simple Actors](https://apify.com/simple.actors) (community)
- **Categories:** Social media, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.50 / 1,000 profile reads

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?

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

## TikTok Latest Posts Monitor

Check any public TikTok profile for what it has posted lately — caption,
hashtags, mentions, views, likes, comments, shares, the video file, photo
carousels, the sound used and the full account record.
**Up to 13 latest posts per profile**, newest first, 45 fields each.

**$0.50 per 1,000 profiles read** — Apify platform usage and proxy included,
nothing else to pay. The charge is per profile and does not depend on how many
posts come back, so a full read and a check that finds one new post cost the
same. A profile that cannot be read is never charged.

**No login, no cookies, no API key, no account of yours involved.** There is no
session to keep alive and nothing of yours to get restricted.

*Unofficial. Not affiliated with, endorsed by, or sponsored by TikTok or
ByteDance.*

> **Read this before you start: up to 13 posts per profile**, usually 10 to 12.
> That is what TikTok shows a logged-out reader, not a setting — there is no
> cursor to ask for more. This is built to check *many* accounts *often*. If you
> need one creator's back catalogue, this is the wrong tool.

### What you give it

Either input, or both together:

| Input | Example |
|---|---|
| **Profile URLs** | `https://www.tiktok.com/@nasa` |
| **Handles** | `nasa`, `@nasa` |

A link to one of the account's videos works too — it is read as the account.

Useful options:

- **Only posts newer than** — `3 days`, `12 hours`, or a date like `2026-08-01`.
  If the account's latest batch does not reach back that far, the run tells you
  so rather than returning a partial list that would look complete.
- **Read each post's full detail** (on by default) — one extra request per post
  for likes, comments, shares, TikTok's own posted time, the sound, hashtags and
  photo-carousel images. Turn it off for a faster, cheaper listing.
- **Read exact follower counts** (on by default) — see the note below.
- **Posts per profile** — up to 13.

### What you get

One row per post, newest first. Every row carries the full account record, so a
row stands on its own.

```jsonc
{
  "id": "7675478347278863629",
  "url": "https://www.tiktok.com/@nasa/video/7675478347278863629",
  "type": "video",
  "caption": "Thanks a million! 🌖🚀",
  "hashtags": [],
  "mentions": [],
  "timestamp": "2026-08-18T20:56:38.000Z",
  "isPinned": false,
  "playCount": 1500000,
  "likeCount": 177100,
  "commentCount": 8831,
  "shareCount": 4208,
  "ownerUsername": "nasa",
  "videoUrl": "https://…",
  "coverUrl": "https://…",
  "musicName": "original sound - NASA",
  "stickerTexts": ["us realizing there's already 1M of you following us"],
  "author": {
    "username": "nasa",
    "nickname": "NASA",
    "followerCount": 1162398,
    "followersAreExact": true,
    "heartCount": 5432780,
    "postCount": 32,
    "isVerified": true
  }
}
```

Photo posts come back as `"type": "photo"` with an `images` array instead of a
video file. Hashtags and mentions are read from TikTok's own entity list, not
guessed from the caption — TikTok writes a mention into the caption using the
account's *display name*, so a post tagging `@wash_wizards` reads
"@Washington Wizards" in the text. The list gives you the handle that was
actually tagged.

### Things worth knowing

**A pinned post is not the newest post.** TikTok shows pinned posts first
whatever their age — one account tested pins a post a month older than the rest.
Rows are sorted by date and the pinned ones are flagged `isPinned`, so you can
sort or filter without being caught by it.

**`videoUrl` expires.** TikTok signs its media links with a few hours' validity.
Download the file promptly if you need it; store `url` as the permanent address.

**Follower counts: exact or rounded.** TikTok's embed rounds — it reports an
account with 1,162,398 followers as "1,200,000", which will not move as the
account grows. This Actor reads the profile page for the real figure, and every
row says which it got in `author.followersAreExact`. If that is `false`, the
counts are rounded to two significant figures.

**Views are always rounded.** TikTok itself rounds `playCount`; there is no
source for an exact figure.

**Posted times are exact when post details are read.** With details off, the
time is recovered from the post's own ID — accurate to about a minute, and
flagged `timestampIsApproximate`.

**Private accounts return an error, not an empty list.** So do accounts that no
longer exist. If you run several accounts at once, one that cannot be read
becomes its own row carrying `error` and `errorDescription`, and the rest still
deliver. An empty result always means "read fine, nothing to report".

### What it costs

**$0.50 per 1,000 profiles read.** One charge per profile, whatever the run
finds. Posts are free: reading a profile costs the same whether thirteen posts
come back or one, so charging for them would bill you for something that is not
what costs.

Two things follow from that:

- **Batch your accounts.** Fifty handles in one run is much cheaper per profile
  than fifty runs of one, because each run pays for its own startup.
- **Take all the posts.** Asking for fewer saves you nothing; the price is for
  reading the profile.

Because the charge is per profile, what you pay per *post* depends on how many
come back:

| Posts returned | Works out at |
|---|---|
| 13 — a full batch | $0.04 per 1,000 posts |
| 11 — a typical account | $0.05 per 1,000 posts |
| 1 — a poll that found one new post | $0.50 per 1,000 posts |

If you are polling with **Only posts newer than** and most checks come back
empty, budget by **profiles checked**, not posts collected — that is what you
are billed on. A profile that cannot be read is never charged, so a list
carrying dead or private accounts costs only for the live ones.

Turning off **Read each post's full detail** makes a run faster and lighter but
does not change the price, so leave it on unless you genuinely only want a
listing.

# Actor input Schema

## `startUrls` (type: `array`):

Public TikTok profile URLs, one per account, e.g. https://www.tiktok.com/@nasa. A link to one of the account's videos works too — it is read as the account. This field only accepts real URLs; to give bare handles like "nasa", use the Handles field below. You can use both together.

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

TikTok handles without the URL, e.g. nasa or @nasa. Use this instead of Profile URLs when you have handles rather than links; the two lists are read together.

## `maxPosts` (type: `integer`):

How many of the latest posts to return per account. TikTok renders one batch to a logged-out reader and offers no way to ask for more, so this is capped at 13 — most accounts return 10 to 12. Lower it only if you want fewer rows; it does not make the run cheaper.

## `onlyPostsNewerThan` (type: `string`):

Keep only posts published after this moment. Accepts an ISO date (2026-08-01) or a window ("3 days", "12 hours"). If the account's latest batch does not reach back that far, the run fails for that account rather than returning a partial list that would read as complete — shorten the window or poll more often.

## `includePostDetails` (type: `boolean`):

On by default. Reads one extra request per post to get its like, comment and share counts, TikTok's own posted time, the music, the hashtags and mentions, and the images of a photo post. Turn it off for a fast, cheap listing: you keep the caption, view count, cover and video file, but engagement counts become null and the posted time is derived from the post id (accurate to about a minute).

## `includeProfileDetails` (type: `boolean`):

On by default. Reads the profile page for the account's exact follower and like counts plus its fuller record. With this off — or if TikTok challenges the page — the counts come from the embed and are rounded to two significant figures (1,200,000 rather than 1,161,914), which will not move as the account grows. Every item says which it got in "author.followersAreExact".

## `proxy` (type: `object`):

Apify Proxy settings. The default datacenter group is enough — TikTok's embed served every datacenter request tested without a challenge, and showed no rate limiting. Switch to residential only if accounts start coming back as read failures.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.tiktok.com/@nasa"
    }
  ],
  "maxPosts": 13,
  "includePostDetails": true,
  "includeProfileDetails": true,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `posts` (type: `string`):

One row per post with its headline numbers.

## `engagement` (type: `string`):

Views, likes, comments, shares and hashtags per post.

## `media` (type: `string`):

Video files, covers, photo carousels and the sound used.

## `profile` (type: `string`):

The account record behind these posts.

## `raw` (type: `string`):

Every field of every item, exactly as pushed.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.tiktok.com/@nasa"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("simple.actors/tiktok-profile-posts").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 = { "startUrls": [{ "url": "https://www.tiktok.com/@nasa" }] }

# Run the Actor and wait for it to finish
run = client.actor("simple.actors/tiktok-profile-posts").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 '{
  "startUrls": [
    {
      "url": "https://www.tiktok.com/@nasa"
    }
  ]
}' |
apify call simple.actors/tiktok-profile-posts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,simple.actors/tiktok-profile-posts"
        }
    }
}

```

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/eA9Rcgv7zJ4zYICzV/builds/hqrUs1JnkOZYwQT0s/openapi.json