Blog/Developer Tools/

Lemon8 Public Data API | SandBase

Read public Lemon8 search, posts, users, and topics with one REST API. No Lemon8 login, no SDK — one SandBase key, built for agent workflows.

By Sophie Lin
Dark cinematic render of Lemon8 search, post, and user data flowing through one API conduit into an agent core

Lemon8 is ByteDance’s lifestyle content app — beauty, food, travel, and wellness posts that make it a strong signal for consumer research, influencer discovery, and content trends across its Western and Southeast Asian markets. Getting at it programmatically usually means reverse-engineering the app, juggling tokens, and rebuilding a scraper each time the app changes.

The SandBase Lemon8 public data API removes that setup tax. It reads Lemon8’s public search results, posts, users, and topics through plain REST endpoints — one SandBase API key, no Lemon8 login and no SDK. The endpoint API reference is the source of truth for each parameter and for the response envelope; the business-payload field names below come from a search call I ran (tested on 2026-09-27, UTC) and are shown as one observed shape — confirm them against a live response, since payloads change over time.

This is not Lemon8’s official open platform. Use Lemon8’s official channels when you need authenticated member actions or a licensed data agreement. Use SandBase when your workflow needs public, read-only data for research and monitoring. Ready to try it? Get a SandBase API key and browse the Lemon8 endpoints.

Key takeaway

  • One API reads Lemon8’s public search, posts, users, topics, and discover feed.
  • The Model API endpoints in this guide are called with POST /v1/api/lemon8/<path> — pass only that endpoint’s params, no SDK, one SANDBASE_API_KEY.
  • Endpoints key off natural identifiers: a query for search, a user_id for a user, an item_id for a post, and a forum_id for a topic.
  • It returns public, read-only data only. There is no posting, no platform login on your side, and no private data; authenticate with a SandBase API key.

Which Lemon8 API do you need?

Your needChooseWhy
Post, act as a member, or use account-authorized dataLemon8’s official channelsMember and account operations run through Lemon8 directly.
Read public search, posts, users, or topicsSandBase Lemon8 public-data APIPlain REST, one SandBase key, structured JSON for read-only workflows.
Private or account-only dataNeither public workflowThat data is out of scope for this public-data guide.

What you can get from the Lemon8 API

The catalog is organized on an app surface. Grouped by job:

  • Search & discover — keyword search and a discover feed.
  • Posts — post detail by item_id, plus an item-id resolver from a share text.
  • Users — public user profile, post list, and follower/following lists, plus a user-id resolver from a share text.
  • Topics — topic (forum) info and its post list.

Check each endpoint’s live API reference for the exact parameters before you build; availability differs by endpoint.

SandBase Lemon8 API page: description, capability tags, and the endpoint list The Lemon8 API page on SandBase — a tagged overview and the endpoint list, each with its path.

What Lemon8 provides vs. what SandBase adds

Public data comes from Lemon8. SandBase does not own or operate Lemon8; it provides a uniform API layer for eligible public-data workflows. Each capability becomes one stable endpoint, auth collapses to a single key, and responses come back as predictable JSON — so an agent can chain “search a keyword → open a post → read the author” along one convention instead of maintaining a scraper.

Quick start: your first call

SandBase exposes more than one API surface. The catalog may show GET paths under /apis/v1/...; this guide uses the vendor-qualified Model API path on each endpoint’s API reference. Do not swap the HTTP method or URL — follow the reference for the endpoint you choose.

Search public posts by keyword:

import os
import requests

resp = requests.post(
    "https://api.sandbase.ai/v1/api/lemon8/app/search",
    headers={
        "Authorization": f"Bearer {os.environ['SANDBASE_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={"query": "skincare"},
)
resp.raise_for_status()
body = resp.json()
if body.get("status") != "completed":
    error = body.get("error", {})
    raise RuntimeError(error.get("message", "Lemon8 request did not complete"))

# The reference guarantees the envelope; the search payload is a list of
# blocks, each with an upstream code and a data object — read defensively
# and confirm the exact paths against a live response.
blocks = body["outputs"][0]["data"]
for block in blocks if isinstance(blocks, list) else []:
    data = block.get("data", {})
    if block.get("code") == 0 and data.get("items"):
        print(len(data["items"]), "items, has_more:", data.get("has_more"))
        break
curl -X POST https://api.sandbase.ai/v1/api/lemon8/app/search \
  -H "Authorization: Bearer $SANDBASE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "skincare"}'

Responses use a consistent envelope: an id, a status, the model name, and — on a completed run — an outputs array whose single item carries the payload under data. A failed or timeout run instead carries error and no outputs, so branch on status before reading outputs[0].data. For search, that payload is a list of blocks; a block with code == 0 carries a data object with items, has_more, search_id, and cursor fields. The block below is a trimmed real response from my search call (tested on 2026-09-27, UTC) — the values move over time, so treat the field names as observed and confirm them against a live response:

{
  "id": "3eb2ad8b-0737-441e-8b6c-eda7c60860c2",
  "status": "completed",
  "model": "lemon8/app/search",
  "outputs": [
    {
      "data": [
        {
          "code": 0,
          "data": {
            "items": [ { "content": "…", "comment_count": 0, "author": {} } ],
            "has_more": true,
            "search_id": "…"
          }
        }
      ]
    }
  ]
}

Response shapes differ by endpoint — inspect one real response and map the exact path per endpoint.

SandBase API reference for a Lemon8 endpoint, showing the vendor-qualified URL and the response schema The endpoint API reference is the source of truth for each parameter name and response path.

Capability map

Capability clusterRepresentative endpointTypical use
Searchlemon8/app/searchKeyword content discovery
Discoverlemon8/app/discover-tabBrowse the discover feed
Post detaillemon8/app/post-detailRead a post by item_id
Userlemon8/app/user-profilePublic user signals by user_id
Topiclemon8/app/topic-infoRead a topic by forum_id

Paging differs by endpoint — search returns a has_more flag with max_cursor/min_cursor and a search_id; pass the cursor back on the next request. Read each endpoint’s schema.

SandBase Lemon8 endpoint list showing search, post, user, and topic endpoints with their paths A slice of the Lemon8 endpoint list on the app surface.

Chaining calls in an agent workflow

Because every endpoint shares the same auth and the same response envelope, an agent can walk from a keyword to an author without special-casing each surface. A common consumer-research pattern looks like this:

  1. Search the keyword. Call lemon8/app/search with a query to get matching posts, paging with the returned cursor while has_more is true.
  2. Open the post. Call lemon8/app/post-detail with an item_id surfaced from search for the full post.
  3. Read the author. Call lemon8/app/user-profile with a user_id, then lemon8/app/user-post-list for their posts.

Each step returns the same { id, status, model, outputs } shape, so your agent branches on status once and reuses the same JSON-reading code across every step.

Common use cases

Lemon8 search API for content discovery

Run lemon8/app/search with a query to survey posts around a topic, then page with the cursor while has_more is true. Input: a query. Output: matching posts plus paging fields. Endpoint: search.

Lemon8 user API for creator research

Read a public user with lemon8/app/user-profile by user_id, then lemon8/app/user-post-list for their posts. Input: a user_id. Output: a user record and post list. Endpoints: user-profile, user-post-list.

Lemon8 topic API for niche research

Read a topic with lemon8/app/topic-info by forum_id, then lemon8/app/topic-post-list for its posts. Input: a forum_id. Output: topic info and posts. Endpoints: topic-info, topic-post-list.

Why run this at the API layer

You could point a headless browser at Lemon8 and parse the app’s payloads, but that path is fragile: the app changes, tokens rotate, and you maintain a scraper instead of shipping features. Reading through one uniform API means your code depends on named JSON fields and a single response envelope rather than an app internal. Auth is one key, and because every endpoint returns the same { id, status, model, outputs } shape, retries, logging, and error handling live in one helper you write once and reuse everywhere.

That uniformity is what makes the workflow composable for an agent. Swap one query for another, swap one user_id for the next, and the code path is identical. Add a fourth read — a topic’s post list, say — and it slots in behind the same helper. The practical payoff is that your time goes to what the data means for your research, not to keeping a scraper alive against a moving target. When you need more than single reads, check the live listing for the endpoint that fits and confirm its parameters before wiring it in.

Limitations and boundaries

  • Public, read-only data only. No posting, following, or private/account-only data.
  • Rate and volume. Treat responses as best-effort reads; as a client-side resilience measure, retry with backoff on transient errors such as HTTP 429.
  • Parameters and shapes follow the upstream surface. A query drives search; identifiers vary (user_id, item_id, forum_id); search returns a list of blocks each with an upstream code; paging uses a cursor with has_more. Inspect a real response and read the schema first.
  • Verify endpoints against the live reference. Availability and fields can change; confirm before building on a specific endpoint.
  • This is not an official Lemon8 partnership. SandBase provides uniform access to public data; respect Lemon8’s terms and applicable rules for your use case.

FAQ

Do I need a Lemon8 developer app or login? No. You authenticate to SandBase with your SANDBASE_API_KEY. These read endpoints do not require a Lemon8 account or OAuth on your side.

What identifies a post, user, or topic? A query drives search; an item_id identifies a post, a user_id a user, and a forum_id a topic. There are also resolvers that turn a share text into an item_id or user_id.

Why is the search payload a list of blocks? Lemon8’s search returns a list of blocks, each with an upstream code and a data object; the block with code == 0 carries the items. Read it defensively and confirm the path against a live response.

Can I read private or account-only data? No. The API returns public data only. Private and account-authorized content are out of scope.

Create a SandBase API key, call search with a query, and inspect the returned schema before you expand to posts, users, or topics. When you are ready: