# Likee Scraper — Public Videos & Creator Profiles (`fetch_cat/likee-public-content-scraper`) Actor

Collect public Likee videos and creator profiles with captions, engagement metrics and cohort analytics. Filter and refresh watch lists for creator research.

- **URL**: https://apify.com/fetch_cat/likee-public-content-scraper.md
- **Developed by:** [Fetch Cat](https://apify.com/fetch_cat) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.70 / 1,000 saved results

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?

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

Collect public Likee videos and creator profiles for creator research and social listening. This Likee scraper exports attributed metrics, captions and timestamps, with filters, bounded history and summaries of the videos actually scanned.

### Quick start

1. Enter one or more public creator handles or profile URLs.
2. Choose videos, creator profiles or both. Set the scan depth and maximum saved rows.
3. Run the Actor, then open its dataset and the `SUMMARY` record.

```json
{
  "profiles": ["Likee_Russia", "baby.miaa"],
  "resultType": "both",
  "maxVideosPerProfile": 50,
  "maxResults": 102
}
```

This recipe requests up to 50 videos per creator and allows space for two profile records. It is an input recipe, not a public saved-task link.

Prefer a video guide? This short Apify walkthrough shows you how to set up and run an Actor. It uses a different Actor, but the setup steps are the same.

https://youtu.be/1OW8gOqlZbY?t=25

### What you get

- **Attributed public video data:** stable video and author IDs, captions, hashtags, mentions, publication dates and available view, like, comment and share counts.
- **Creator profiles:** public biography, avatar, follower/following counts and total likes where supplied by Likee.
- **Comparable cohorts:** sample sizes, medians, averages and optional creator-relative engagement scores over scanned videos, before filters.
- **Repeatable watch lists:** optional only-new output with history separated by normalized targets, output mode and filters.
- **Explicit coverage:** per-input outcomes, scan limits and unavailable reasons outside the dataset. Unknown values remain null.

### Who is it for?

**Creator research teams** can compare public creator profiles and recent-video cohorts before building a shortlist. **Social listening teams** can refresh a known watch list and use the returned captions and metrics in their own reporting workflow.

### Input settings

| Settings | What they control |
| --- | --- |
| `profiles`, `userIds` | Public handles/profile URLs, or internal numeric author IDs supplied as strings. Internal-ID resolution needs a listing entry with a public author handle. |
| `videos` | Public share URLs, author/video URLs, or `author/videoId` references. A bare numeric video ID is insufficient. |
| `resultType` | `videos`, `profiles` or `both`. Individual video inputs require `videos` or `both`. |
| `maxResults`, `maxVideosPerProfile` | Maximum saved rows across the run, including profiles, and maximum scanned source entries per creator. |
| `sorting` | `latest` retains source recent-video order. `popular` ranks by views within the scanned cohort, not the creator's whole history. |
| `minViews`, `minLikes`, `minComments`, `minShares`, `minEngagementRate` | Video thresholds applied before saving and result charging. Engagement rate is `(likes + comments + shares) / views × 100`. |
| `publishedAfter`, `publishedBefore` | Inclusive UTC publication boundaries. A date alone means midnight, not the end of that day. |
| `engagementScore` | Adds video ratios against the same creator's scanned median reach and engagement. Standalone videos have no comparison cohort. |
| `onlyNew` | Returns matching videos not remembered in this watch-list scope. Requires video output. The first run establishes the baseline. |

**Individual video recipe:** use `{"videos":["https://likee.video/v/sepkYQ"],"resultType":"videos","maxResults":1}`. An author/video reference is found by scanning that author's history up to `maxVideosPerProfile`. A requested ID not found before the limit remains an incomplete extraction, not proof of deletion.

**Monitoring recipe:** add `"onlyNew": true` to your creator watch-list input. Keep its normalized targets, filters and output mode unchanged to reuse the same history. No schedules are created by the Actor.

Invalid individual targets are skipped with field/index warnings while valid targets continue. An invalid overall mode or date range produces a correction warning without extraction. Check `SUMMARY` for a working input recipe.

### Output data

Video and creator records share a dataset. Use `recordType` to distinguish them.

| Record | Useful fields |
| --- | --- |
| Video identity | `videoId`, `authorId`, `authorUsername`, `authorNickname`, `authorProfileUrl` |
| Content | `caption`, `hashtags`, `mentions`, `postedAt`, `scrapedAt` |
| Metrics | `playCount`, `likeCount`, `commentCount`, `shareCount`, `engagementRate` |
| Available media | `coverImageUrl`, `videoFileUrl`, `postUrl`, `shareUrl`, music metadata and video dimensions |
| Creator profile | Public profile details and `analytics` describing the actual scanned video cohort |
| Provenance | `sourceInput`, explicit cohort sizes and completeness, optional metric precision and creator-relative ratios |

Public listing responses often lack video file URLs and share links. Those fields remain null rather than being reconstructed from internal IDs. Share-page counters can be rounded and are labeled with `metricPrecision`. Time-window post counts remain null when scanned history does not cover the interval.

The `SUMMARY` key-value record reports per-input outcomes, saved row counts, filters, previously seen videos, skipped private entries and limits. Status and error messages are not dataset rows.

#### Download your results

Open your run's dataset, choose **Export** and select JSON, CSV or Excel. JSON keeps nested fields together. CSV and Excel are useful when you want to review the records in a spreadsheet.

See [Apify's download and export guide](https://docs.apify.com/storage/dataset#apify-console) for the available formats and field options.

### Pricing

The **Actor Start** charge applies when a run starts, including empty runs and runs that return input warnings.

The **result** charge applies to each completed saved video or creator profile row. Profile rows count toward `maxResults`, including profiles with no matching videos. Excluded videos, previously seen videos and unavailable targets do not create paid result rows. Useful completed rows can still be charged when another input fails.

See the [live Pricing tab](https://apify.com/fetch_cat/likee-public-content-scraper/pricing) for current rates and discounts.

### Tips for best results

- **Start with a small cohort.** Confirm the creator identity and populated metrics before increasing scan depth.
- **Leave room for profiles.** In `both` mode, allow extra saved rows for creator summaries.
- **Compare like-for-like samples.** Use similar depths and date boundaries across creators. Popular ranking cannot see older videos outside that sample.
- **Keep monitoring scope stable.** Changes to targets, filters or output mode create a separate baseline. History retains the latest 10,000 emitted video IDs per scope, so evicted IDs can reappear.

### Limits and caveats

- Anonymous public content only. No login, private content, contact enrichment, media downloads, full comment text or platform-wide search/hashtag discovery.
- Scan limits are not whole-account coverage. Creator analytics describe scanned public videos before filters, not every post on the account.
- Some share links redirect to an app or homepage without usable public video data. These remain extraction failures rather than invented empty results.
- Unavailable targets succeed with truthful reasons. Blocking, malformed source responses, incomplete required lookups and essential storage/billing failures remain failures. Useful completed rows are preserved.
- Null metrics do not satisfy numeric filters, even when the minimum is zero. Public-source changes can affect availability and field population.
- Only-new history is not a transactional exactly-once delivery guarantee. A failed run can leave accessible rows and incomplete history. Start a new run rather than resurrecting an interrupted run.

### Automation and integrations

#### Save your settings for next time

Once you have an input that works for you, [save it as an Apify task](https://docs.apify.com/actors/running/tasks). This keeps your settings together so you can use them again without filling in the form from scratch.

#### Run on a schedule

Need fresh results regularly? You can [schedule the Actor or a saved task](https://docs.apify.com/actors/running/schedules) in your own account. The Actor itself does not create or enable schedules.

Use only-new mode to retrieve newly observed matching videos. Comparing metrics across runs or sending alerts belongs to your own workflow.

#### Send results to your other tools

Use **n8n, Make or Zapier** to connect this scraper to the rest of your workflow. For example, you could pass its results to an AI assistant or add records to a spreadsheet. Follow the [Apify integration guides](https://docs.apify.com/integrations) for your chosen tool.

For a custom connection, an [Apify webhook](https://docs.apify.com/integrations/webhooks) can notify your app when a run finishes or fails. Your app can then fetch the results or handle the failure.

### API usage

Collect a bounded creator cohort from your app, then retrieve the dataset for analysis. The Node.js and Python clients wait for the run to finish. cURL starts a run and returns its details. Follow that run to completion, then fetch its `defaultDatasetId`.

See the official [JavaScript client guide](https://docs.apify.com/api/client/js), [Python client guide](https://docs.apify.com/api/client/python) and [Actor runs API reference](https://docs.apify.com/api/v2/acts-runs-post).

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~likee-public-content-scraper/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"profiles":["Likee_Russia"],"maxVideosPerProfile":10,"maxResults":11}'
```

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/likee-public-content-scraper').call({
  profiles: ['Likee_Russia'], maxVideosPerProfile: 10, maxResults: 11,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/likee-public-content-scraper').call(run_input={
    'profiles': ['Likee_Russia'], 'maxVideosPerProfile': 10, 'maxResults': 11,
})
print(client.dataset(run['defaultDatasetId']).list_items().items)
```

### MCP and AI agents

You can ask your assistant to collect Likee data and help you work with it. The scraper retrieves public records. Your assistant can summarize them, compare creators or prepare a file afterward.

Connect through the [Apify MCP server and configurator](https://mcp.apify.com/) using the [official setup and sign-in guide](https://docs.apify.com/mcp). The [official Apify plugin](https://docs.apify.com/agents/plugins) can configure supported coding assistants. You can also use [Apify AI in Console](https://docs.apify.com/account/apify-ai), which is currently in beta and asks for confirmation before starting an Actor.

#### Choose your assistant

- **Claude and Claude Code:** [Apify setup guide](https://docs.apify.com/integrations/claude).
- **ChatGPT and Codex:** [Apify setup guides](https://docs.apify.com/integrations/openai).
- **Grok Bot:** [Apify plugin guide](https://docs.apify.com/integrations/grok-bot).
- **Gemini CLI:** [MCP server setup](https://geminicli.com/docs/tools/mcp-server/).

#### Connect just this scraper

To keep your setup focused on this scraper, add this configuration to a compatible MCP client:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/likee-public-content-scraper"
    }
  }
}
```

Use OAuth when your client supports it, or its documented secure Bearer-token configuration. Never put a real token in a prompt or public example.

#### Use Apify's general server

Alternatively, connect to Apify's general server at `https://mcp.apify.com` and ask it to find `fetch_cat/likee-public-content-scraper`, inspect the schema and retrieve your chosen data. Both URLs use Apify's hosted service. Follow the returned run/dataset rather than starting duplicate runs. Check current Pricing before authorizing charges.

#### Example requests

- “Get recent public videos from Likee_Russia and make a spreadsheet of captions, dates and engagement counts.”
- “Collect 50 recent public videos each from Likee_Russia and baby.miaa, then compare their median views using those samples.”
- “Retrieve the public Likee video at this share link and summarize its caption, author and available engagement metrics.”

### Pay with x402

A funded agent can use the official [x402 setup](https://docs.apify.com/integrations/x402) to obtain a prepaid, spend-capped API token through [Apify AGI](https://agi.apify.com/), then use the API or a supported authenticated MCP connection.

Direct per-request MCP payment is a separate route with platform eligibility restrictions. It is not verified for this Actor. Use the documented prepaid-token flow when available, rather than assuming direct payment support.

Apify handles payments. Follow its current guide for setup and terms. Keep wallet keys and payment tokens out of prompts and public examples. The [agentic payment guide](https://docs.apify.com/agents/payments) also describes MPP and eligible Skyfire integrations.

### FAQ

**Can I use this as a Likee video data API?**

Yes. Submit supported public targets through the Apify API and retrieve attributed video/profile records from the resulting dataset. It is not an official Likee API.

**Does popular mean the most viewed videos on the whole account?**

No. It ranks only the scanned recent-video cohort. Increase scan depth when appropriate and inspect completeness before drawing broader conclusions.

**Can I get a Likee profile without collecting video rows?**

Choose `profiles`. The Actor still scans a bounded video cohort for analytics, but saves only the creator record. Internal numeric IDs cannot resolve metadata from an empty listing.

**Why can the dataset be empty?**

Targets may be explicitly unavailable, filters may exclude the scanned videos, or only-new mode may have no unseen matches. Check `SUMMARY`. A saved creator profile can still be a result when video filters exclude every video.

### Related Actors

- [TikTok Profile Scraper](https://apify.com/fetch_cat/tiktok-profile-scraper) — export public TikTok creator profiles and available recent-video metadata.
- [X / Twitter Posts Scraper](https://apify.com/fetch_cat/tweet-scraper) — retrieve public posts from profile and post URLs, with text, authors and engagement counts.
- [Bilibili Video Search Scraper](https://apify.com/fetch_cat/bilibili-video-search-scraper) — search public Bilibili videos and export author, engagement and publication metadata.
- [TikTok Sound Scraper](https://apify.com/fetch_cat/tiktok-sound-scraper) — retrieve public TikTok videos using specific sounds, with creator and engagement metadata.
- [Instagram AI Transcript Extractor](https://apify.com/fetch_cat/instagram-ai-transcript-extractor) — transcribe public Instagram Reels and videos into speech text and available timestamped segments.

### Support and feedback

For custom additions or integrations, email <hello@fetchcat.dev>.

Found an error or have a feature request? [Open an issue](https://apify.com/fetch_cat/likee-public-content-scraper/issues) with the run URL, a non-sensitive input example and what you expected.

See [Apify's guide to sharing runs in Actor issues](https://docs.apify.com/account/collaboration/general-resource-access#automatically-sharing-runs-via-actor-issues). Sharing a run gives the developer access to its input, logs and default results, so use a run containing no sensitive data. Leave out API tokens, passwords, cookies, private documents and personal data. Use a public sample URL or a redacted example instead.

Tried this scraper? We'd love to hear how it worked for you. [Leave a review](https://apify.com/fetch_cat/likee-public-content-scraper/reviews) to help others choose the right tool and help us improve it. Your feedback means a lot to us.

Made with care for curious people, AI agents and the possibilities in data. ♥

# Changelog

This Actor's version history is a separate document: https://apify.com/fetch_cat/likee-public-content-scraper/changelog.md

# Actor input Schema

## `profiles` (type: `array`):

Enter public handles or HTTPS likee.video/@handle URLs. Use userIds for internal numeric IDs.

## `userIds` (type: `array`):

Enter internal numeric author IDs as strings, not video IDs. Resolution needs a listing entry with a public author handle. Private item content is excluded. Empty listings cannot supply creator metadata.

## `videos` (type: `array`):

Enter https://likee.video/v/CODE share URLs, https://likee.video/@author/video/ID URLs, or author/ID. Author/ID lookup scans at most maxVideosPerProfile and never saves unrelated videos.

## `resultType` (type: `string`):

Choose saved record types. Profile records are billed rows too. Video inputs require videos or both. Profile analytics always describe scanned videos before filtering.

## `maxResults` (type: `integer`):

Cap all saved and billed rows, including profile records. Inputs run in order. At the cap, later inputs and profile summaries can remain unprocessed.

## `maxVideosPerProfile` (type: `integer`):

Bound source history scanned per creator or author/video lookup. This is a scan limit, not a promise of complete history. A missing direct video at this limit remains an extraction failure, not proven unavailable.

## `sorting` (type: `string`):

Popular ranks only the scanned recent-video cohort, not every video on the creator account. Increase scan depth to compare more history.

## `onlyNew` (type: `boolean`):

Remember successfully saved and billed video IDs in an account-owned named key-value store, separately per watch list and filter scope. First use creates a baseline. Retains the latest 10,000 emitted IDs per scope; evicted IDs can reappear. Requires videos or both. Profile rows are emitted only when new matching videos were saved. No schedules are created.

## `engagementScore` (type: `boolean`):

Add ratios against median reach and engagement of all videos scanned from the same creator. Standalone video inputs have no comparison cohort, so their ratios are null.

## `minViews` (type: `number`):

Keep videos meeting this source-reported view threshold. Unknown values do not qualify, even at zero.

## `minLikes` (type: `number`):

Keep videos meeting this like threshold. Filtering happens before saving and billing.

## `minComments` (type: `number`):

Keep videos meeting this comment-count threshold. Comment text is not collected.

## `minShares` (type: `number`):

Keep videos meeting this share-count threshold. Unknown values do not qualify.

## `minEngagementRate` (type: `number`):

Keep videos where (likes + comments + shares) / views × 100 meets this threshold. All four metrics must be known and views positive.

## `publishedAfter` (type: `string`):

Use YYYY-MM-DD or an ISO UTC timestamp. A date means midnight UTC. Inclusive boundary; undated videos do not qualify.

## `publishedBefore` (type: `string`):

Use YYYY-MM-DD or an ISO UTC timestamp. A date means midnight UTC, not the end of that day. Must not precede publishedAfter.

## Actor input object example

```json
{
  "profiles": [
    "Likee_Russia",
    "baby.miaa"
  ],
  "resultType": "both",
  "maxResults": 10,
  "maxVideosPerProfile": 10,
  "sorting": "latest",
  "onlyNew": false,
  "engagementScore": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `summary` (type: `string`):

No description

# 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 = {
    "profiles": [
        "Likee_Russia",
        "baby.miaa"
    ],
    "maxResults": 10,
    "maxVideosPerProfile": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/likee-public-content-scraper").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 = {
    "profiles": [
        "Likee_Russia",
        "baby.miaa",
    ],
    "maxResults": 10,
    "maxVideosPerProfile": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/likee-public-content-scraper").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 '{
  "profiles": [
    "Likee_Russia",
    "baby.miaa"
  ],
  "maxResults": 10,
  "maxVideosPerProfile": 10
}' |
apify call fetch_cat/likee-public-content-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fetch_cat/likee-public-content-scraper"
        }
    }
}
```

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/6NZ0GVotHr55qbrbp/builds/BN0f9pdilpFRP0w19/openapi.json