# Blibli Homepage Recommendation & Ad Placement Tracker (`zucchini_gopher_m2v/blibli-homepage-recommendation-tracker`) Actor

Snapshot what Blibli's algorithm places on its homepage tabs right now: 'Untukmu' picks, the 'Zona affiliate' feed, and category tabs -- product recommendations with rank order plus paid ad-banner slots. For visibility monitoring and ad intelligence. No login needed.

- **URL**: https://apify.com/zucchini\_gopher\_m2v/blibli-homepage-recommendation-tracker.md
- **Developed by:** [Faisal Ahdan naufal](https://apify.com/zucchini_gopher_m2v) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 results

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

## Blibli Homepage Recommendation & Ad Placement Tracker

See what [Blibli](https://www.blibli.com)'s own algorithm is placing on its
homepage right now — not what a search or category browse returns, but the
actual "Untukmu" (For You), "Zona affiliate", and auto-generated category
tabs a real visitor sees, with rank order and paid ad slots included.

Built for brand/seller **homepage visibility monitoring** ("is my product
being surfaced, and where"), **affiliate product discovery** (the
"Zona affiliate" tab is a curated affiliate-marketing feed), and
**homepage-ad competitive intelligence** (which brands are buying banner
placement, and when their campaign runs).

No login, no API key, no cookies. HTTP-only — no browser.

### One event, no `mode`

Every other actor in this developer's Blibli portfolio uses a `mode` input
when a target needs genuinely different endpoints with different output
shapes (see `blibli-promo-extractor`'s three modes). This one doesn't,
deliberately: every tab hits the *same* endpoint and returns the *same*
tile shapes. Tabs are a filter dimension of one event — "what's on the
homepage feed right now" — not separate events, so they're a `tabs` array
input instead of a `mode` enum.

```json
{ "tabs": ["TAB_1", "TAB_4"], "maxPagesPerTab": 15 }
```

Leave `tabs` empty to auto-discover and sweep every tab Blibli currently
exposes (8 at the time of writing — this list itself changes as Blibli adds
seasonal tabs, so the actor always re-fetches it rather than hardcoding
names).

### Output — three tile types in one feed

Blibli's feed interleaves three unrelated tile shapes; `_recordType` tells
them apart. Blibli's own fields are passed through **verbatim**; fields
this actor adds are prefixed with `_`.

**`product`** — a real recommendation:

```json
{
  "_recordType": "product",
  "_tabName": "TAB_1",
  "_tabTitle": "Untukmu",
  "_rankInFeed": 2,
  "name": "Hanasui Collagen Water Sunscreen SPF30 30gr",
  "sku": "HAO-70179-00023",
  "merchantName": "Hanasui Flagship Store",
  "_offerPrice": 30600,
  "_discountPercent": 15,
  "_productUrl": "https://www.blibli.com/p/...",
  "_personalizationSource": "brs",
  "_personalizationLogic": ";;DEFAULT_RERANK"
}
```

**`ad_banner`** — a paid brand placement, no product at all:

```json
{
  "_recordType": "ad_banner",
  "_tabName": "TAB_1",
  "_brandAdId": "BA00002377_homePage",
  "_adBrandNames": ["KGA - New Launch"],
  "_adRedirectUrl": "https://www.blibli.com/promosi/kga-advan-laptop",
  "_adStartTime": "2026-08-27T17:00:00Z",
  "_adEndTime": "2026-09-09T16:59:59Z"
}
```

**`category_card`** — a curated "trending now" collection tile, not a
single SKU:

```json
{
  "_recordType": "category_card",
  "name": "Sepatu Sneakers Pria",
  "_cardLabel": "Lagi laris",
  "_cardDescription": "1,7 rb terjual bulan ini",
  "_productUrl": "https://www.blibli.com/top-selling-page/..."
}
```

`_personalizationSource` / `_personalizationLogic` / `_strategyId` are
Blibli's own algorithm-internals fields, passed through — a rare public
window into which recommendation strategy served a given placement.

### Input reference

| Field | Description |
| --- | --- |
| `tabs` | Tab short-codes to sweep (e.g. `["TAB_1","TAB_4"]`). Empty = every tab Blibli currently exposes. |
| `maxPagesPerTab` | Hard cap on pages per tab (default 15, ~20 items/page). This is a personalized, re-ranked feed with no reliable "end" — see Known limits. |
| `maxItemsPerTab` | Stop emitting for a tab after this many records. `0` = no limit beyond `maxPagesPerTab`. |
| `includeAdBanners` | Keep paid ad-banner tiles (default `true`). Turn off for product recommendations only. |
| `proxyConfiguration` | Apify Residential + country `ID` recommended for long runs. |

### Known limits

- **No absolute "all recommendations."** This is a live, re-ranked feed
  (Blibli's own field literally says `personalizationLogic:
  "DEFAULT_RERANK"`), not a fixed catalogue — `maxPagesPerTab` is what
  actually bounds a run for personalized tabs, not an end-of-list signal.
  Auto-generated category tabs (`AUTOMATIC` source) do terminate cleanly on
  an empty page; personalized tabs (`MANUAL` source, e.g. "Untukmu") may
  not, by design of what a recommendation feed is.
- **Blibli's own `paging.total_page` is unreliable on this endpoint** —
  observed oscillating between requests to the same tab. This actor never
  uses it as a stop condition; see CRAWLING\_METHOD.md for the measurement.
- **Anonymous/default ranking only.** No session or cookies are sent, so
  this reflects Blibli's no-login ranking, not any specific shopper's
  personalized feed.

### Pricing

**$1.00 per 1,000 results** — pay-per-event, one event
(`apify-default-dataset-item`), charged per record in the dataset. No
subscription, no minimum.

Store category: **ECOMMERCE** — the actor's output is marketplace
product/placement data.

<details>
<summary>How this price was set</summary>

This developer's other Blibli actor (`blibli-promo-extractor`) priced at
$1.00/1k against a researched competitor band of $0.50-$4.99/1k for
Indonesian-marketplace scrapers, with measured operating cost of
$0.009/1k. This actor shares the identical stack (same HTTP client, same
Cloudflare bypass, same 1024 MB memory footprint, no browser) so its
operating cost is expected to be in the same range; a fresh Store search
specifically for homepage-recommendation/ad-placement scrapers (a much
narrower niche than general product scraping) found no directly comparable
actor at the time of writing, so this price matches the sibling actor's
proven point in the same niche/stack/portfolio rather than a fabricated
competitor figure.

</details>

### Reliability

Blibli sits behind **Cloudflare**. The actor clears it HTTP-only with TLS
impersonation plus the `Referer` header Cloudflare's rule requires — no
browser, no CAPTCHA solver. On a block it retries with exponential backoff
while rotating both the TLS fingerprint and (when a proxy is configured)
the egress IP.

Runs never fail silently: a blocked run, an upstream schema change, bad
input, or a genuinely empty result each emit a diagnostic row carrying
`_error` and `_errorDetail`.

See [CRAWLING\_METHOD.md](CRAWLING_METHOD.md) for the full WAF analysis,
endpoint discovery (including the `id`-vs-`name` trap and the tile shapes
found during local testing), and why `paging.total_page` can't be trusted.

# Actor input Schema

## `tabs` (type: `array`):

Which homepage feed tabs to sweep, by their short code (e.g. "TAB\_1" for 'Untukmu'/For You, "TAB\_4" for 'Zona affiliate'). Leave empty to auto-discover and sweep every tab Blibli currently exposes on the homepage -- the tab list itself (name/title/source) changes over time as Blibli adds seasonal or category tabs.

## `maxPagesPerTab` (type: `integer`):

Hard cap on pages fetched per tab. This is a personalized, re-ranked recommendation feed, not a fixed catalogue -- Blibli's own paging metadata is unreliable here, so this cap (not an 'end of list' signal) is what actually stops a sweep. ~20 items per page.

## `maxItemsPerTab` (type: `integer`):

Stop emitting records for a tab after this many. 0 means no limit beyond maxPagesPerTab.

## `includeAdBanners` (type: `boolean`):

Keep the paid brand-ad banner tiles that are interleaved with organic recommendations (they carry brandAdId/brandNames/redirectUrl instead of a product). These reveal which brands are buying homepage ad placement. Turn off to keep product recommendations only.

## `proxyConfiguration` (type: `object`):

Blibli is behind Cloudflare. Apify Residential proxy with country 'ID' is recommended for long runs; short runs usually succeed without a proxy.

## Actor input object example

```json
{
  "tabs": [],
  "maxPagesPerTab": 15,
  "maxItemsPerTab": 0,
  "includeAdBanners": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All homepage feed tiles (product recommendations and ad banners) from this run.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("zucchini_gopher_m2v/blibli-homepage-recommendation-tracker").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("zucchini_gopher_m2v/blibli-homepage-recommendation-tracker").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 '{}' |
apify call zucchini_gopher_m2v/blibli-homepage-recommendation-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zucchini_gopher_m2v/blibli-homepage-recommendation-tracker"
        }
    }
}

```

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/e3rDGJvWbQ6QbHBNW/builds/lKImX1ZTeN1tVFaDF/openapi.json