# Likee Scraper - Profile Videos, Views and Likes, No Login (`dami_studio/likee-scraper`) Actor

Paste Likee handles or profile links and get every video back: caption, hashtags, views, likes, comments, shares, engagement rate, sound and post time. Newest or most viewed first, date and count filters, and a mode that sends only videos posted since the last run. No login.

- **URL**: https://apify.com/dami_studio/likee-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.20 / 1,000 videos

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

**Paste Likee handles or profile links and get each profile's videos back, one row per video**: the caption, hashtags, mentions, views, likes, comments, shares, engagement rate, cover image, sound and the time it was posted, newest first or most viewed first.

No video files, though. Likee's video list gives the cover image and the numbers but not the video itself, and Likee's web pages for single videos now send you to its home page, so a row has no link that plays the video. Each video is identified by its `postId`.

| | |
|---|---|
| **Input** | Likee handles or profile links: `itz.danila`, `@itz.danila`, `https://likee.video/@itz.danila` |
| **Output** | One row per video: caption, hashtags, mentions, views, likes, comments, shares, engagement rate, cover image, sound, publish time, author |
| **Ceiling** | 3,000 videos per profile, 10,000 per run, 200 profiles per run |
| **Account needed** | None. No Likee login, no cookies |
| **Price** | $6.50 per 1,000 videos, flat on every plan. The free plan's $5 a month covers about 769 |

### 🔍 What Likee Scraper does

Give it a list of creators and it reads each profile's videos from the latest post back, until it has as many as you asked for or the profile runs out. The author is checked on every video before it is written.

Switch the order to **Most viewed first** and it reads up to the profile's newest 3,000 videos, then hands back the most watched ones, highest first. On the two large profiles we tested, 2,087 and 1,247 videos, that was every video they had.

Filters run on the actor's side, before anything is written: posted on or after a date, posted on or before a date, and minimum views, likes, comments, shares or engagement rate. A video your filters leave out is never charged.

**Only videos posted since the last run** turns it into a monitor: it remembers the newest video it handled on each profile, so a daily schedule sends each video once. The engagement score compares each video with the creator's own median, so a small account's breakout clip stands out next to a big account's average one.

### 📋 What data you get from each Likee video

| What you get | Field |
|---|---|
| Video id and publish time (UTC) | `postId`, `publishedAt` |
| Caption, the separate title some videos carry, and the long description on a few | `caption`, `title`, `longDescription` |
| Hashtags (Likee's own list plus any written in the caption) and mentioned accounts | `hashtags`, `mentions` |
| Views, likes, comments, shares | `views`, `likes`, `comments`, `shares` |
| Engagement rate, in percent | `engagementRate` |
| Video or photo post, cover image, photo links, frame size | `postType`, `coverUrl`, `imageUrls`, `videoWidth`, `videoHeight` |
| The sound used | `musicTitle`, `musicAuthor`, `musicId`, `soundId` |
| Who posted it | `authorHandle`, `authorNickname`, `authorUid`, `authorAvatarUrl`, `country` |
| Optional: how it did against the creator's median | `authorMedianViews`, `viewsVsAuthorMedian`, `engagementVsAuthorMedian` |
| Optional, one free row per profile: followers, total likes, bio, posting rate, average and median views, top video | `recordType: "profile"` |

### ▶️ How to scrape Likee videos

1. Open Likee Scraper and press **Try for free**.
2. In **Profiles**, add one handle or profile link per line, for example `itz.danila`.
3. Set **Videos per profile**. 30 is a good first try.
4. Open **Filters** if you only want recent or popular videos, and **Extra fields** for the profile row or the engagement score.
5. Press **Start**, then open the **Output** tab or export the dataset as JSON, CSV or Excel.

Start it with nothing filled in and you get one free example row, so you can see the shape before you spend anything.

### 💰 How much does it cost to scrape Likee videos?

$6.50 per 1,000 videos, the same on every plan. The free plan's $5 a month covers about 769 videos.

You pay for video rows only. Profile rows, the example row an empty run returns, note rows about profiles that could not be read, and videos your filters leave out are all free. If you set a maximum cost for a run, it stops at that limit and every video it delivered was charged once.

### 📥 What you give it

| Field | What it does | When left empty |
|---|---|---|
| `profileUrls` | Handles or profile links, one per line, up to 200. A link to a single video is skipped with a free note | No profiles: one free example row |
| `maxVideosPerProfile` | The most videos from each profile, 1 to 3,000 | 30 |
| `maxItems` | The most videos in the whole run, 1 to 10,000 | 10,000 |
| `profileVideoSorting` | `latest` (newest first) or `popular` (most viewed first, out of the newest 3,000) | `latest` |
| `onlyNewVideos` | Only videos posted since the last run with the same filters. Works with `latest` only | Off |
| `publishedAfter`, `publishedBefore` | A day (`2026-01-31`), a day and time (`2026-01-31T18:00:00Z`) or a span back from now (`7 days`, `2 weeks`, `3 months`). Days are read in UTC | No date limit |
| `minViews`, `minLikes`, `minComments`, `minShares` | Leave out videos below these counts | No minimum |
| `minEngagementRate` | Leave out videos below this rate, in percent (5 means 5%) | No minimum |
| `findInProfile` | A profile to search for one video you can see in the app but have no link to | Off |
| `findByCaption`, `findByDate` | Part of that video's caption, the day it was posted (UTC), or both | Off |
| `findAllMatches` | Return every match instead of the first | Off |
| `includeProfileSummary` | Add one free profile row per profile | Off |
| `engagementScore` | Add the three comparison fields to each video | Off |

A date the actor cannot read, a find without a caption or date, or **Most viewed first** together with new videos only, stops the run before anything is read, with a free `BAD_INPUT` note saying what to change.

```json
{
  "profileUrls": ["itz.danila", "https://likee.video/@baby.miaa"],
  "maxVideosPerProfile": 50,
  "publishedAfter": "30 days",
  "minViews": 10000,
  "includeProfileSummary": true
}
```

### 📤 What you get back

A real row from a test run, with the avatar link left out for length:

```json
{
  "recordType": "video",
  "postId": "7203406476020708378",
  "publishedAt": "2023-02-23T17:36:06.000Z",
  "caption": "ребят , не подскажите , а где рейтинг?😳 #Like #trend #Лайк #ИтзДанила",
  "title": "ТРЕНД 2018",
  "longDescription": null,
  "hashtags": ["Like", "trend", "dialog", "Лайк", "ИтзДанила"],
  "mentions": [],
  "views": 10022,
  "likes": 1160,
  "comments": 33,
  "shares": 11,
  "engagementRate": 12.01,
  "postType": "video",
  "coverUrl": "https://videosnap.like.video/eu_live/9uJ/0GTvy3_4.jpg?wmk_sdk=1&type=8",
  "imageUrls": [],
  "videoWidth": 576,
  "videoHeight": 1024,
  "musicTitle": "itz.danila",
  "musicAuthor": "itz.danila",
  "musicId": null,
  "soundId": "2908439180020708378",
  "authorHandle": "itz.danila",
  "authorNickname": "itz.danila",
  "authorUid": "1341551642",
  "country": "RU",
  "inputProfile": "itz.danila",
  "scrapedAt": "2026-10-03T16:13:14.559Z"
}
```

| Field | Worth knowing |
|---|---|
| `engagementRate` | (likes + comments + shares) / views x 100, two decimals. `null` when a video has no views |
| `hashtags` | Likee's own list for the post, plus tags written in the caption that its list leaves out. Likee's list can hold tags the caption does not show, like `dialog` |
| `title` | A second line of text some creators add; about a third of the videos we read had one |
| `musicTitle`, `musicAuthor` | For a creator's original sound these are the creator's own name. A licensed track has its real title and a `musicId` instead of a `soundId`. About a quarter of the videos we read carried no sound details, and then all four are `null` |
| `postType`, `imageUrls` | `photo` posts carry their pictures in `imageUrls`; videos leave it empty |
| `authorAvatarUrl` | Carries a time-limited token from Likee, about two days. Save the picture if you need it later |
| `country` | The country code Likee attaches to the post |

### 🧾 Reading the output

Every row has a `recordType`:

- `video`: a video you paid for, one charge each.
- `profile`: the free profile row, only with **Add a profile row** on. Its averages are worked out over the videos this run read for that profile, before filters, so they describe the creator rather than your query.
- `note`: a free row explaining a profile that gave no videos, with `_diagnostic: true`, an `errorCode` and a plain `error`.
- `sample`: the free example row, with `_sample: true`. It only appears when the input has no profiles.

Filter on `recordType` equal to `video` and you have exactly the rows you were charged for.

| `errorCode` | Means |
|---|---|
| `BAD_INPUT` | Something in the input could not be used; `details` says what |
| `PROFILE_NOT_FOUND` | Likee has no profile with that handle |
| `PRIVATE_PROFILE` | Likee marks the profile private |
| `NO_VIDEOS` | The profile has no public videos |
| `FILTERED_OUT` | Fewer videos than asked passed your minimums; it says how many were checked |
| `NOT_FOUND_IN_PROFILE` | The find matched nothing |
| `NO_NEW_VIDEOS` | Nothing new since the last run |
| `MORE_NEW_VIDEOS` | More than 3,000 new videos since the last run, so only the newest were looked at |
| `LIKEE_UNAVAILABLE`, `PARTIAL_RESULTS` | Likee stopped answering; run it again in a few minutes |
| `UNEXPECTED_ANSWER` | Likee answered with another profile's data, which was thrown away |
| `MAX_ITEMS_REACHED`, `TIME_LIMIT`, `COST_LIMIT`, `COST_LIMIT_REACHED` | The run hit your video limit, its time limit or its maximum cost; `profilesNotRead` lists the profiles it did not reach |
| `MONITOR_STORE_UNAVAILABLE`, `UNEXPECTED_ERROR` | Something went wrong on our side; please report it |

### 💡 What people use it for

- Anyone managing Likee creators who still tracks their numbers by screenshot: a weekly run gives each account's posting rate, median views and best video.
- Brands checking a creator before paying for a post. Most viewed first plus the engagement score shows whether the big numbers come from one lucky clip or from steady work.
- A team that wants every new upload from a set of accounts in a sheet the next morning: schedule it daily with **Only videos posted since the last run** on.
- Hashtag and sound research inside a niche, by pulling a few hundred videos from the accounts that lead it and counting `hashtags` and `musicTitle`.

### 🚧 What it does not do

- No video files and no link that plays a video, for the reasons at the top of this page.
- Profiles only: no hashtag pages, no keyword search, no trending feed.
- No single video links. To pull one video out of a profile, use **Find a video in this profile** with part of its caption or the day it was posted.
- No comments, followers lists or liked videos.
- Private profiles stay private: Likee shows nothing of theirs.
- Counts are a snapshot taken when the run reads the profile.
- **Most viewed first** looks at a profile's newest 3,000 videos, not older ones.

### 🧭 Which short-video scraper do you need?

| If you want | Use |
|---|---|
| Videos from Likee profiles, with views, likes, comments and shares | This one |
| A TikTok profile's newest videos, or a TikTok keyword search | [TikTok Scraper](https://apify.com/dami_studio/tiktok-scraper) |
| Every reel on an Instagram profile's reels tab | [Instagram Reel Scraper](https://apify.com/dami_studio/instagram-reel-scraper) |

### ❓ Questions people ask

#### Do I need a Likee account to scrape profiles?

No. There is nothing to sign in to and nothing to paste. The actor reads what Likee shows any visitor.

#### Why do the numbers differ from what I see in the Likee app?

The counts are read at the moment the run reaches the profile, and a video people are still watching keeps climbing, so the app shows a little more a few minutes later. Two of our test runs read the same 60 videos about two minutes apart, and the views had moved on 55 of them.

#### How does "Only videos posted since the last run" work?

The first run for a profile returns what your other settings allow and remembers the newest video it handled. Each run after that returns only newer videos, oldest first. If a run stops early at one of your limits, the next run carries on from the last video it delivered, so nothing is skipped and nothing is sent twice. The memory lives in a key-value store called `likee-scraper-monitor` on your account, one record per profile and filter set. Delete a record there to start that profile over.

#### Can I call it from code or connect it to an AI assistant?

Yes. The [API tab](https://apify.com/dami_studio/likee-scraper/api/python) has ready-made code for Python, JavaScript and the command line. For Claude, ChatGPT or another MCP client, connect `https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/likee-scraper`. Either way the run happens on your Apify account at the same price.

#### Is scraping Likee legal?

It reads public profiles and videos that anyone can see without logging in. Rows still name people, and GDPR and similar laws cover that, so have a reason for keeping the data. Apify's write-up on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) is a good starting point, and we are not lawyers.

### 🆘 If something breaks

Open the **Issues** tab on the actor page. Include the profiles you used and the run ID, and the log is enough for us to see what happened.

# Actor input Schema

## `profileUrls` (type: `array`):

Likee handles or profile links, one per line: <code>itz.danila</code>, <code>@itz.danila</code> or <code>https://likee.video/@itz.danila</code>. Up to 200 per run. A link to a single video is not read; the find section further down is for that.

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

The most videos to return from each profile, from 1 to 3,000. Left empty, it is 30.

## `maxItems` (type: `integer`):

The most videos to return across all profiles in one run, from 1 to 10,000. Left empty, the run stops at 10,000.

## `profileVideoSorting` (type: `string`):

<b>Newest first</b> starts at the profile's latest post and works back. <b>Most viewed first</b> looks through up to the profile's newest 3,000 videos and returns them by view count, highest first.

## `onlyNewVideos` (type: `boolean`):

Turns the run into a monitor. The first run for a profile returns what your other settings allow and remembers the newest video it saw. Every run after that returns only videos posted since, oldest first, so a schedule never sends the same video twice. The memory is kept per profile and per set of filters, in a key-value store called <code>likee-scraper-monitor</code> on your account. Works with Newest first only.

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

Only videos posted on or after this date: a day (2026-01-31), a day and time (2026-01-31T18:00:00Z) or a span back from now (7 days, 2 weeks). Days are read in UTC. Videos outside the range are skipped and not charged.

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

Only videos posted on or before this date. Same formats as above.

## `minViews` (type: `integer`):

Skip videos with fewer views. Skipped videos are not charged.

## `minLikes` (type: `integer`):

Skip videos with fewer likes.

## `minComments` (type: `integer`):

Skip videos with fewer comments.

## `minShares` (type: `integer`):

Skip videos shared fewer times.

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

Skip videos with a lower engagement rate. The rate is (likes + comments + shares) / views x 100, the same figure as the <code>engagementRate</code> field, so 5 means 5%.

## `findInProfile` (type: `string`):

A handle or profile link to look in, for when you can see a video in the Likee app but have no link to it. Give part of its caption, the day it was posted, or both, and only the matching video comes back.

## `findByCaption` (type: `string`):

Part of the caption, in any case. A few distinctive words are usually enough.

## `findByDate` (type: `string`):

The day it was posted, read in UTC. Can be combined with the caption.

## `findAllMatches` (type: `boolean`):

Off: stops at the first match. On: returns every video that matches, up to the per-profile limit.

## `includeProfileSummary` (type: `boolean`):

Adds one free row per profile, marked <code>recordType: "profile"</code>: followers, total likes, bio, and figures worked out over the videos this run read for it, such as posts per week, average and median views and the most viewed video.

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

Adds <code>authorMedianViews</code>, <code>viewsVsAuthorMedian</code> and <code>engagementVsAuthorMedian</code> to each video: how it did against the creator's median over the videos this run read for them. Above 1 beats their usual.

## Actor input object example

```json
{
  "profileUrls": [
    "itz.danila"
  ],
  "maxVideosPerProfile": 30,
  "profileVideoSorting": "latest",
  "onlyNewVideos": false,
  "findAllMatches": false,
  "includeProfileSummary": false,
  "engagementScore": false
}
```

# Actor output Schema

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

Every row in the default dataset. Videos carry recordType "video": postId, publishedAt, caption, hashtags, mentions, views, likes, comments, shares, engagementRate, coverUrl, music fields and the author's handle, nickname and uid. A run with no profile returns one free example row (recordType "sample"); a profile that cannot be read returns a free note (recordType "note") with an errorCode.

# 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 = {
    "profileUrls": [
        "itz.danila"
    ],
    "maxVideosPerProfile": 30,
    "profileVideoSorting": "latest"
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/likee-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 = {
    "profileUrls": ["itz.danila"],
    "maxVideosPerProfile": 30,
    "profileVideoSorting": "latest",
}

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/likee-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 '{
  "profileUrls": [
    "itz.danila"
  ],
  "maxVideosPerProfile": 30,
  "profileVideoSorting": "latest"
}' |
apify call dami_studio/likee-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/likee-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/SDhuJ5EibGgU1AhT8/builds/7QFjPO2jycBADymvF/openapi.json