# Vigloo Trending Scraper - Top 10 & Popularity Ranking (`hgservices/vigloo-trending-scraper`) Actor

Get the Vigloo Top 10 chart and a full ranking of every short drama by 24-hour popularity score, for one or more countries. Each row has the rank, score, Top 10 position, title, genres, views, likes and bookmarks. Schedule it to track trends. No login needed.

- **URL**: https://apify.com/hgservices/vigloo-trending-scraper.md
- **Developed by:** [Harish Garg](https://apify.com/hgservices) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 scraped programs

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

Get the **Vigloo Top 10 chart** and a **full popularity ranking of every Vigloo short drama**, for one or more countries. Each row has the drama's **rank, 24-hour popularity score, Top 10 position, title, genres, views, likes and bookmarks**.

**No Vigloo account, app, login or cookies are needed.** Run the Actor on a **schedule** to track which short dramas trend over time, download the data as JSON, CSV or Excel, or ask an AI assistant such as Claude or ChatGPT what is trending on Vigloo.

### What does Vigloo Trending Scraper do?

[Vigloo](https://www.vigloo.com) is a short-drama streaming app with vertical, mobile-first series. The app shows a **Top 10** chart, and Vigloo gives every drama a **popularity score** for the last 24 hours.

For each country that you select, Vigloo Trending Scraper ranks all the dramas available in that country by their popularity score and saves one row for each drama, most popular first. For each drama you get:

- **Rank:** the place in the country by 24-hour popularity score (1 = most popular)
- **Top 10 position:** the place in Vigloo's own Top 10 chart, when the drama is in it
- **Score:** the popularity score, the time when Vigloo last updated it, and the ranking region
- **Drama details:** ID, title, genres, release date, episode count, age rating, Vigloo Original or not, poster and link
- **Engagement:** the counts of views, likes and bookmarks

The full US ranking has about 550 dramas. Each country takes a few seconds.

Because the Actor runs on the Apify platform, you also get API access, scheduling, integrations and run monitoring.

### Why track Vigloo trends?

- **Trend tracking:** see which short dramas, genres and story tropes rise and fall every day.
- **Market research:** compare what is popular in the US, Korea, Japan, India and the Middle East.
- **Content strategy:** find the formats that work before you produce or license a short drama.
- **Competitor monitoring:** follow the performance of new Vigloo releases from day one.
- **Dashboards:** schedule the Actor every hour or day and chart the scores in Google Sheets, Looker Studio or your BI tool.

### Input

| Field | What it does | Example |
|-------|--------------|---------|
| **Countries** | Two-letter country codes. Each country gets its own ranking. | `["us", "kr", "jp"]` |
| **Language** | The language of the titles and genres | `en` |
| **Max dramas per country** (optional) | Save only the top N dramas of each country. Leave empty for the full ranking. | `100` |

**Languages:** English (`en`), Korean (`ko`), Japanese (`ja`), Spanish (`es`), Indonesian (`id`), Portuguese (Brazil) (`pt-BR`), Thai (`th`), Arabic (`ar`), Chinese Traditional (`zh-Hant`), Chinese Simplified (`zh-Hans`), Hindi (`hi`) and French (`fr`).

#### Input example

The top 50 dramas in the US, Korea and Saudi Arabia, with English titles:

```json
{
  "countries": ["us", "kr", "sa"],
  "language": "en",
  "maxProgramsPerCountry": 50
}
```

### Output

One row for each drama in each country, most popular first. This is the #1 drama in the US on 20 October 2026:

```json
{
  "rank": 1,
  "top10Rank": 1,
  "score": 941,
  "scorePeriod": "24h",
  "scoreUpdatedAt": "2026-10-20T16:00:00.025253110Z",
  "rankingRegion": "US",
  "programId": 15003457,
  "title": "You Can't Escape Me",
  "genres": ["LGBTQ+", "Romance"],
  "releaseDate": "2026-10-08",
  "episodeCount": 51,
  "viewCount": 4191154,
  "likeCount": 126575,
  "bookmarkCount": 175901,
  "isOriginal": true,
  "ageRating": 15,
  "posterUrl": "https://asset.vigloo.com/US000P67S01/asset/thumbnails/default/en.png",
  "url": "https://www.vigloo.com/en/content/15003457",
  "country": "us",
  "language": "en",
  "scrapedAt": "2026-10-20T16:41:52+00:00"
}
```

#### Data fields

| Field | Description |
|-------|-------------|
| `rank` | Place in the country by 24-hour popularity score. Empty when Vigloo gives no score; these dramas come last. |
| `top10Rank` | Place in Vigloo's Top 10 chart. Empty when the drama is not in the chart. |
| `score`, `scorePeriod`, `scoreUpdatedAt` | Popularity score, its period (24 hours) and when Vigloo computed it (ISO 8601, UTC) |
| `rankingRegion` | Vigloo's ranking region for the country: `US`, `KR`, `JP`, `INDIA`, `MENA` or `ROOT` |
| `programId`, `title`, `genres` | Drama ID, title and genres |
| `releaseDate`, `episodeCount`, `ageRating`, `isOriginal` | Release date, number of episodes, minimum viewer age (0 = all ages) and Vigloo Original |
| `viewCount`, `likeCount`, `bookmarkCount` | Engagement counts |
| `posterUrl`, `url` | Poster image and drama page on vigloo.com |
| `country`, `language` | The country and language of the row |
| `scrapedAt` | When the row was saved (ISO 8601, UTC) |

In Apify Console, the **Output** tab shows the ranking as a table with posters. You can export it as JSON, CSV, Excel, XML or HTML.

### How to use Vigloo Trending Scraper

#### In Apify Console

1. Open the Actor and go to the **Input** tab.
2. Enter one or more **Countries**, for example `us` and `kr`.
3. Select a **Language** for the titles.
4. Enter **Max dramas per country**, for example `100`, or leave it empty to get the full ranking.
5. Click **Start**.
6. Open the **Output** tab to see the ranking, or export it.
7. To build a history of the ranking, click **Save as a new task**. On the task, add a **Schedule**, for example every day at 09:00.

#### With the Apify API (HTTP)

Run the Actor and get its results in one request. Replace `YOUR_API_TOKEN` with your token from **Settings → API & Integrations** in Apify Console.

```bash
curl -X POST "https://api.apify.com/v2/acts/hgservices~vigloo-trending-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"countries": ["us"], "maxProgramsPerCountry": 10}'
```

The request waits for the run to finish and returns the rows as JSON. Add `?format=csv` or `?format=xlsx` to the URL to get CSV or Excel.

#### With the JavaScript client

Install the client with `npm install apify-client`, then run:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('hgservices/vigloo-trending-scraper').call({
    countries: ['us', 'kr'],
    maxProgramsPerCountry: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const row of items) {
    console.log(row.country, row.rank, row.score, row.title);
}
```

#### With the Python client

Install the client with `pip install apify-client` (version 3.0 or later), then run:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("hgservices/vigloo-trending-scraper").call(
    run_input={"countries": ["us", "kr"], "maxProgramsPerCountry": 10}
)
if run is None:
    raise RuntimeError("The run was not found.")

for row in client.dataset(run.default_dataset_id).iterate_items():
    print(row["country"], row["rank"], row["score"], row["title"])
```

#### With Claude, ChatGPT and other AI assistants (MCP)

Connect your AI assistant to the **Apify MCP server**. The assistant can then run Vigloo Trending Scraper for you and answer from the results. Use this server URL to give the assistant this Actor as a tool:

```
https://mcp.apify.com?tools=hgservices/vigloo-trending-scraper
```

- **Claude (claude.ai or Claude Desktop):** open **Settings → Connectors**, click **Add custom connector** and paste the URL.
- **Claude Code:** run `claude mcp add --transport http apify "https://mcp.apify.com?tools=hgservices/vigloo-trending-scraper"`.
- **ChatGPT:** turn on **developer mode** in the settings for apps and connectors, then create a connector with the URL.
- **Cursor, VS Code, Codex and other MCP clients:** add the URL as a remote (HTTP) MCP server. With the Apify CLI, you can also run `apify mcp install cursor --tools hgservices/vigloo-trending-scraper` (or `vscode`, `codex` or `claude-code`).

Sign in with your Apify account when asked. Then ask in plain language, for example:

- *"What are the top 10 Vigloo dramas in the US today?"*
- *"Compare the most popular Vigloo genres in Korea and Japan."*
- *"Which Vigloo Originals are in the top 20 in India?"*

#### With integrations

Send the results to **Google Sheets, Slack, email, Zapier, Make, n8n, Airbyte** or any **webhook** from the Actor's **Integrations** tab. For example, post the new US Top 10 to a Slack channel every morning.

### Tips

- **Schedule it.** One run is one snapshot. Run the Actor every day or every hour, and use `scrapedAt` and `scoreUpdatedAt` to chart the changes.
- **Pick one country per ranking region.** Vigloo uses one ranking for some groups of countries. For example, `us`, `gb`, `ca` and `au` share the `US` ranking, and most countries outside the US, Korea, Japan, India and the Middle East share the `ROOT` ranking. The catalogs can still be a little different.
- **Get more data about a drama.** Use **Vigloo Drama Scraper** for the full drama record (synopsis, tags, cast) and **Vigloo Episode Scraper** for the episode list.

### Limits

- **One score window.** Vigloo gives a 24-hour popularity score only. It does not give weekly or monthly scores.
- **The score is Vigloo's own number.** Vigloo does not explain how it computes the score. Use it to compare dramas, not as a view count.
- **The Top 10 chart can differ from the score order.** The chart is Vigloo's own list. `top10Rank` shows it as it is in the app, and `rank` shows the order by score.

### FAQ, disclaimers and support

**Can I use Vigloo Trending Scraper as a Vigloo API?**
Yes. Call the Actor through the Apify API, as shown above, and get the Vigloo ranking as structured JSON, CSV or Excel. You have no scraping code to maintain.

**Do I need a Vigloo account or the app?**
No. The Actor reads only the public data that vigloo.com shows to any visitor. It never logs in.

**Do I need a proxy?**
No. You do not need to set up a proxy.

**Is it legal to scrape Vigloo?**
The Actor collects only public catalog and ranking data about dramas. It does not collect personal data. Posters are protected by copyright. You are responsible for using the data in line with Vigloo's terms of service and the law in your country.

**I found a problem or need a feature.**
Open an issue on the **Issues** tab, and we will look into it. Custom solutions are available on request.

# Actor input Schema

## `countries` (type: `array`):

Two-letter country codes (ISO 3166-1), one per line, for example us, kr, jp, in, sa or br. Each country gets its own ranking. Vigloo shares one popularity ranking across some countries (for example us, gb, ca and au).

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

Language of the drama titles and genres.

## `maxProgramsPerCountry` (type: `integer`):

Save only the top N dramas of each country. Leave empty to save the full ranking (about 550 dramas in the US).

## Actor input object example

```json
{
  "countries": [
    "us"
  ],
  "language": "en",
  "maxProgramsPerCountry": 100
}
```

# Actor output Schema

## `ranking` (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 = {
    "countries": [
        "us"
    ],
    "maxProgramsPerCountry": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("hgservices/vigloo-trending-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 = {
    "countries": ["us"],
    "maxProgramsPerCountry": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("hgservices/vigloo-trending-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 '{
  "countries": [
    "us"
  ],
  "maxProgramsPerCountry": 100
}' |
apify call hgservices/vigloo-trending-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hgservices/vigloo-trending-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/ROw5nxuPlUdgAxgUW/builds/8ipACwVTIRIdapmYQ/openapi.json