# Lemon8 Scraper (`automation-lab/lemon8-scraper`) Actor

Extract public Lemon8 posts, creators, media, hashtags, publish dates, and engagement metrics from searches and URLs.

- **URL**: https://apify.com/automation-lab/lemon8-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 7 total users, 4 monthly users, 72.9% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.07 / 1,000 item processeds

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?

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

## Lemon8 Scraper

Extract public Lemon8 posts, creators, captions, media, hashtags, dates, and engagement metrics into a clean dataset.

Use topic searches or paste public Lemon8 discover, post, hashtag, and creator URLs. The Actor renders each public page, reads Lemon8's structured page state, deduplicates posts, and exports normalized records.

### What does Lemon8 Scraper do?

Lemon8 Scraper turns public Lemon8 content into analysis-ready JSON, CSV, Excel, XML, or RSS data.

It collects:

- Post IDs and URLs
- Titles and captions
- Creator names, usernames, avatars, and follower counts
- Image and media URLs
- Hashtags and topic provenance
- Publish and update timestamps
- Likes, comments, saves, and views
- Region and collection timestamps

### Who is it for?

#### Social-listening teams

Monitor emerging conversations and compare engagement across topics.

#### Influencer marketers

Find creators and assess audience and post performance signals.

#### Agencies

Refresh client research datasets on a schedule and deliver exports automatically.

#### Trend researchers

Build reproducible datasets for content, creator, and hashtag analysis.

### Why use this Lemon8 scraper?

- One Actor covers searches and public URLs.
- Every post has stable source and query provenance.
- Post IDs are deduplicated across inputs.
- Structured page state is more reliable than visual text parsing.
- Failed sources return structured error rows instead of hiding problems.
- SHADER proxy support keeps browser collection cost-efficient.

### How to scrape Lemon8 posts

1. Open the Actor input page.
2. Add one or more topic queries, such as `travel`.
3. Optionally paste public Lemon8 URLs.
4. Set the maximum number of posts.
5. Click **Start**.
6. Export the dataset in your preferred format.

### Input

```json
{
  "queries": ["travel"],
  "maxItems": 20
}
```

You can also use URLs:

```json
{
  "startUrls": [
    { "url": "https://www.lemon8-app.com/discover/travel" }
  ],
  "maxItems": 20
}
```

#### Input fields

| Field | Type | Description |
|---|---|---|
| `queries` | string\[] | Public Lemon8 topics or hashtags |
| `startUrls` | RequestList sources | Public Lemon8 URLs |
| `maxItems` | integer | Global number of unique posts to save |
| `pageLoadWaitSecs` | integer | Extra rendered-page wait time |
| `proxyConfiguration` | object | Apify Proxy settings |

### Output

Each dataset row describes one public Lemon8 post.

```json
{
  "postId": "7525499229712745015",
  "postUrl": "https://www.lemon8-app.com/@erionnedanielle/7525499229712745015",
  "title": "Best Countries to Visit by Month ✈️🌴",
  "caption": "Best Countries to Visit by Month ✈️🌴\n\nAre any of these destinations on your Bucketlist?",
  "authorName": "Erie",
  "authorUsername": "erionnedanielle",
  "authorFollowers": 17347,
  "hashtags": ["bucketlist", "lemon8travel"],
  "likes": 2116,
  "comments": 22,
  "saves": 2296,
  "views": 101151,
  "query": "travel"
}
```

### Lemon8 data fields

| Field | Meaning |
|---|---|
| `postId` | Stable Lemon8 post identifier |
| `postUrl` | Public post URL |
| `title` | Post title |
| `caption` | Combined title and public text |
| `authorId` | Creator identifier |
| `authorName` | Creator display name |
| `authorUsername` | Creator link name |
| `authorUrl` | Public creator URL |
| `authorAvatarUrl` | Avatar image URL |
| `authorFollowers` | Public follower count |
| `mediaType` | Lemon8 article class |
| `mediaUrls` | Public image URLs |
| `hashtags` | Hashtags parsed from caption |
| `publishedAt` | ISO publish timestamp |
| `updatedAt` | ISO update timestamp |
| `likes` | Like count |
| `comments` | Comment count |
| `saves` | Save count |
| `views` | Read/view count |
| `region` | Lemon8 content region |
| `sourceUrl` | Input page that produced the row |
| `query` | Originating query, when used |
| `scrapedAt` | Collection timestamp |

### How much does it cost to scrape Lemon8?

The Actor uses pay-per-event pricing: a small start charge plus one charge per saved post. Your Apify subscription tier determines the exact discounted per-post price shown in Console.

Use a low `maxItems` value for first tests. Browser and proxy usage are included in your platform usage separately according to your Apify plan.

### Search and hashtag monitoring

Schedule a run daily or weekly with the same query list. Store each run in a named dataset or send results to your warehouse. Use `postId` as the deduplication key across runs.

### Creator and influencer research

Filter output by `authorFollowers`, saves, views, or engagement counts. Group records by `authorUsername` to compare creators and identify frequently appearing accounts.

### Tips for reliable runs

- Start with broad public discover topics known to have web results.
- Keep the default SHADER proxy unless a specific region needs another route.
- Increase `pageLoadWaitSecs` only when rendered state loads slowly.
- Use multiple inputs in one run to benefit from cross-source deduplication.
- Treat structured error rows as a signal to retry or review an unsupported page.

### Apify integrations

Connect Lemon8 Scraper to:

- Google Sheets for campaign shortlists
- Slack for trend alerts
- Zapier or Make for no-code workflows
- Webhooks for run-completion notifications
- Amazon S3, Google Drive, or a database for archival
- LangChain and LlamaIndex for content analysis

### API usage

Run the Actor programmatically with JavaScript, Python, or cURL. Each example starts a run and lets you retrieve the default dataset through the Apify API.

#### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/lemon8-scraper').call({
  queries: ['travel'],
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/lemon8-scraper').call(run_input={
    'queries': ['travel'],
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL API example

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~lemon8-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"queries":["travel"],"maxItems":20}'
```

### Use Lemon8 Scraper with MCP

Use the actor-scoped MCP endpoint:

`https://mcp.apify.com?tools=automation-lab/lemon8-scraper`

#### Claude Code

```bash
claude mcp add --transport http apify-lemon8 \
  'https://mcp.apify.com/?tools=automation-lab/lemon8-scraper'
```

Authenticate with Apify when Claude Code opens the connection.

#### Claude Desktop, Cursor, and VS Code

Add this server to the client's MCP JSON configuration (`claude_desktop_config.json` in Claude Desktop, **MCP: Open User Configuration** in Cursor, or `.vscode/mcp.json` in VS Code):

```json
{
  "servers": {
    "apify-lemon8": {
      "type": "http",
      "url": "https://mcp.apify.com/?tools=automation-lab/lemon8-scraper"
    }
  }
}
```

Restart the client if it does not discover the tool immediately, then complete Apify authentication.

Example prompts:

- “Scrape 20 public Lemon8 travel posts and rank them by saves.”
- “Monitor these Lemon8 creator URLs and return posts published this week.”
- “Find recurring creators in this Lemon8 dataset.”
- “Summarize the hashtags with the highest median engagement.”

### Scheduling and webhooks

Create an Apify schedule for recurring monitoring. Attach a webhook to send the dataset ID to your pipeline after a successful run. Keep snapshots keyed by `postId` to detect newly discovered posts or engagement changes.

### Error handling

If one source fails, the Actor continues with the remaining sources and writes a row containing `error`, `sourceUrl`, `query`, and `scrapedAt`. Invalid non-Lemon8 URLs fail validation before browser work begins.

### Legality

#### Is it legal to scrape Lemon8?

This Actor accesses public web pages without requiring login credentials. Use the data responsibly, follow applicable laws and Lemon8's terms, avoid collecting sensitive personal data, and respect rights such as deletion and copyright. You are responsible for your use case.

### FAQ

#### Does it require a Lemon8 account?

No. It works with public web content and does not request account credentials.

#### Can it download images?

It exports public media URLs. Your downstream workflow can download them when permitted.

#### Why did a query return an error row?

Some terms do not have a public Lemon8 discover page, or Lemon8 may temporarily return a challenge page. Try a known public topic URL, keep Apify Proxy enabled, or retry later.

#### How are duplicate posts handled?

Records are deduplicated by stable Lemon8 post ID across all queries and URLs in one run.

#### Can I monitor engagement over time?

Yes. Schedule recurring runs and compare likes, comments, saves, and views by `postId`.

#### Can I scrape private profiles?

No. The Actor only processes public Lemon8 surfaces.

### Related social media scrapers

Explore other public social-media data tools from [automation-lab](https://apify.com/automation-lab) for cross-platform monitoring workflows.

### Support

For reproducible support, include the run ID, sanitized input, failed source URL, and expected result. Do not post private credentials or personal data in support requests.

# Actor input Schema

## `queries` (type: `array`):

Lemon8 topics to discover, such as travel, skincare, or meal prep.

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

Public Lemon8 discover, post, hashtag, or creator URLs.

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

Maximum number of unique post records saved across all inputs.

## `pageLoadWaitSecs` (type: `integer`):

Extra time for Lemon8's rendered public data to load.

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

Apify Proxy is recommended. The default SHADER group is cost-efficient and works for Lemon8.

## Actor input object example

```json
{
  "queries": [
    "travel"
  ],
  "startUrls": [],
  "maxItems": 20,
  "pageLoadWaitSecs": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ]
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "queries": [
        "travel"
    ],
    "startUrls": [],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/lemon8-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 = {
    "queries": ["travel"],
    "startUrls": [],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/lemon8-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 '{
  "queries": [
    "travel"
  ],
  "startUrls": [],
  "maxItems": 20
}' |
apify call automation-lab/lemon8-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/lemon8-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/fyeSGLRTRhqdCBdlX/builds/6hQAlY9UnceeV6R11/openapi.json