# 8kun Scraper: Boards, Threads & Posts (`thescrapelab/8kun-public-boards-threads-scraper`) Actor

Scrape public 8kun boards, threads, posts, replies, timestamps, links, and attachment metadata without login, API key, or 8kun API. Export JSON, CSV, or Excel.

- **URL**: https://apify.com/thescrapelab/8kun-public-boards-threads-scraper.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Categories:** Social media, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 delivered posts

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?

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

## 8kun Scraper: Boards, Threads & Posts

Scrape public 8kun boards, threads, posts, and replies into structured datasets. This 8kun scraper extracts timestamps, quote relationships, external links, thread state, and attachment metadata from public HTML—without requiring an 8kun login, API key, or source API.

Use the results for public-source research, journalism, trust-and-safety investigation, academic analysis, brand-risk monitoring, dashboards, or AI workflows. Every run is an independent snapshot, making the Actor easy to schedule while keeping collection predictable and bounded.

### Use cases

- Monitor named public boards or threads for trust-and-safety and brand-risk research.
- Build structured datasets for academic studies, investigative journalism, or public-source intelligence.
- Track thread activity, quote relationships, links, and attachment metadata over scheduled snapshots.
- Feed bounded public-post data into review queues, dashboards, spreadsheets, or AI classification workflows.

### What you can collect

- Live threads discovered from public board catalogs
- Original posts and optional replies
- Board, thread, and post identifiers
- Public author, tripcode, and poster-ID labels when displayed
- UTC publication timestamps
- Plain-text post content
- Quoted post relationships and external links
- Sticky, locked, and cyclic thread indicators
- Attachment filenames, formats, dimensions, sizes, source URLs, and thumbnails

Attachments are not downloaded or copied. The Actor returns visible metadata and source-hosted URLs only.

### Quick start

The defaults are ready to run. They check three live threads from the public `/tech/` catalog and return three opening posts as a quick, low-cost sample:

```json
{
  "boards": ["tech"],
  "maxItems": 3
}
```

To scrape a specific public thread without catalog discovery:

```json
{
  "startUrls": [
    "https://8kun.top/tech/res/123456.html"
  ],
  "includeReplies": true,
  "maxPostsPerThread": 100,
  "maxItems": 100
}
```

Replace the example thread URL with a current public URL.

### Input options

| Field | Description |
| --- | --- |
| `boards` | Board names without slashes, such as `tech` or `biz`. Defaults to `tech`. |
| `startUrls` | Optional direct board, catalog, board-page, or thread URLs. |
| `maxItems` | Maximum total result rows for the run. Defaults to 3; maximum 1,000. |
| `includeReplies` | Save replies as separate rows. Off by default; turn it on for full conversations. |
| `maxThreadsPerBoard` | Advanced: maximum live threads opened per board. Defaults to 3. |
| `maxPostsPerThread` | Advanced: maximum rows saved from any one thread. Defaults to 1. |
| `since` | Optional inclusive ISO-8601 lower timestamp boundary. |
| `until` | Optional inclusive ISO-8601 upper timestamp boundary. |
| `proxyConfiguration` | Optional Apify Proxy or custom proxy settings. Direct requests are used by default. |

When direct URLs are provided and `boards` remains the unchanged `tech` default, only the direct URLs are processed. Add explicit non-default boards or board URLs when you want to combine catalog and direct-thread targets.

Date filters apply to posts found in current live catalogs or supplied threads. They do not search historical archives.

### Dataset output

Each dataset item represents one original post or reply:

```json
{
  "recordType": "post",
  "board": "tech",
  "boardTitle": "Technology",
  "threadId": 12345,
  "postId": 12347,
  "isOriginalPost": false,
  "subject": null,
  "author": "Anonymous",
  "tripcode": null,
  "posterId": "abc123",
  "postedAt": "2026-01-01T00:00:00.000Z",
  "commentText": ">>12345\nExample reply.",
  "quotedPostIds": [12345],
  "externalLinks": [],
  "containsSpoiler": false,
  "attachments": [],
  "threadReplyCount": 2,
  "isSticky": false,
  "isLocked": false,
  "isCyclic": false,
  "threadUrl": "https://8kun.top/tech/res/12345.html",
  "postUrl": "https://8kun.top/tech/res/12345.html#12347",
  "scrapedAt": "2026-09-17T00:00:00.000Z",
  "unreviewedUserGeneratedContent": true
}
```

The run also writes an `OUTPUT` record containing effective settings, counts, failures, warnings, duration, and billing status. It deliberately excludes post excerpts and attachment URLs.

### Scheduling snapshots

Every run starts fresh and never reads earlier Actor runs. To monitor a board or thread:

1. Save a task with the targets and limits you need.
2. Schedule that task at an appropriate interval.
3. Compare post IDs or `postedAt` timestamps in your downstream automation.

Use `since` to bound a scheduled snapshot when you already know the desired time window. The Actor does not create schedules, named storage, or cross-run profiles for you.

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
actor_client = client.actor("thescrapelab/8kun-public-boards-threads-scraper")

run = actor_client.call(
    run_input={
        "boards": ["tech"],
        "maxItems": 10,
        "includeReplies": True,
    },
    max_total_charge_usd=0.05,
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["board"], item["postId"], item["postedAt"])
```

You can also download results from the Dataset tab as JSON, CSV, Excel, XML, RSS, or JSONL.

### Cost and performance

The Actor uses lightweight HTML requests rather than a browser. Cost depends mainly on the number of board catalogs and thread pages requested.

In private-beta tests on September 17, 2026, direct-connection runs returned 100 rows in 16.1 seconds at 256 MB, 500 rows in 1 minute 59 seconds at 512 MB, and 1,000 rows in 3 minutes 56 seconds at 512 MB. The 1,000-row run used approximately $0.0196 of platform resources. Treat these as small benchmarks, not guarantees: source response time, proxies, and page distribution can change runtime and cost.

- Direct thread URLs are the cheapest option.
- Start with one board and a small `maxThreadsPerBoard`.
- Use `maxPostsPerThread` and `maxItems` as hard output controls.
- Direct connections are the low-cost default; enable a proxy only when necessary.
- No chargeable result should be created for duplicates or posts removed by date filters.
- The Actor is configured for 512 MB. Lower memory settings are not recommended for large runs.

The Actor uses simple introductory pay-per-event pricing. You pay only for a run start and posts actually delivered:

- `$0.001` when a run starts.
- `$0.0003` for each post delivered to the default dataset.

| Delivered posts | Current price |
| ---: | ---: |
| 1 | $0.0013 |
| 10 | $0.0040 |
| 100 | $0.0310 |
| 1,000 | $0.3010 |

Platform usage is included in these event prices. Set `maxTotalChargeUsd` in API calls to enforce a run-level spending limit. The minimum useful limit is `$0.0013` (one start plus one delivered post). The Apify Console Pricing tab remains the source of truth if prices change later.

### Limitations

- Only anonymously accessible public HTML is supported.
- The Actor does not use 8kun JSON endpoints or private APIs.
- Site-wide board discovery and historical archive discovery are not included.
- Deleted, expired, private, challenged, or unavailable pages cannot be returned.
- Source markup and availability can change without notice.
- Attachment URLs remain hosted by the source and may later disappear.
- Poster IDs are public source labels and must not be treated as verified identities.
- Date filtering cannot recover posts that are no longer present in the selected live pages.

### Responsible use and content warning

8kun contains unreviewed user-generated content that may be offensive, explicit, misleading, unlawful, or disturbing. The Actor does not classify, endorse, moderate, or verify source content. It does not download attachments, and its logs and run summary do not reproduce post text.

Use the Actor only for legitimate and lawful purposes. Do not use results for harassment, stalking, doxxing, discrimination, unlawful surveillance, threats, or redistribution of material you do not have the right to use. Technical accessibility does not grant intellectual-property or downstream-processing rights. Apply appropriate access controls and retention periods to exported data.

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by 8kun or its operators.

### Support

If a public page stops producing results, open an issue from the Actor page and include the run ID, target type, and board name. Do not include post text, attachment links, credentials, or sensitive investigation details in support messages.

# Actor input Schema

## `boards` (type: `array`):

Board names without slashes, for example tech or biz. When you add a direct URL and leave tech unchanged, only the URL is scraped.

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

Paste public 8kun board, catalog, or thread URLs when you already know what to scrape.

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

Maximum number of post rows saved to the dataset for the entire run.

## `includeReplies` (type: `boolean`):

Save replies as separate rows. Off by default for a fast first run; turn it on to collect full conversations.

## `maxThreadsPerBoard` (type: `integer`):

Maximum number of live threads opened from each selected board.

## `maxPostsPerThread` (type: `integer`):

Maximum opening post plus replies saved from any one thread.

## `since` (type: `string`):

Inclusive ISO-8601 timestamp, for example 2026-09-01T00:00:00Z.

## `until` (type: `string`):

Inclusive ISO-8601 timestamp, for example 2026-09-30T23:59:59Z.

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

Optional Apify Proxy or custom proxy settings.

## Actor input object example

```json
{
  "boards": [
    "tech"
  ],
  "startUrls": [],
  "maxItems": 3,
  "includeReplies": false,
  "maxThreadsPerBoard": 3,
  "maxPostsPerThread": 1,
  "since": "",
  "until": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Open the complete dataset of public original posts and replies produced by this snapshot.

## `summary` (type: `string`):

Open effective settings, target counts, failures, warnings, timing, and billing information without post excerpts.

# 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 = {
    "boards": [
        "tech"
    ],
    "maxItems": 3,
    "includeReplies": false,
    "maxThreadsPerBoard": 3,
    "maxPostsPerThread": 1,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("thescrapelab/8kun-public-boards-threads-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 = {
    "boards": ["tech"],
    "maxItems": 3,
    "includeReplies": False,
    "maxThreadsPerBoard": 3,
    "maxPostsPerThread": 1,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("thescrapelab/8kun-public-boards-threads-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 '{
  "boards": [
    "tech"
  ],
  "maxItems": 3,
  "includeReplies": false,
  "maxThreadsPerBoard": 3,
  "maxPostsPerThread": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call thescrapelab/8kun-public-boards-threads-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thescrapelab/8kun-public-boards-threads-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/aE2llkXfaGpmufxpm/builds/BgL0Al6B8iHf7TCoP/openapi.json