# Alternative Social Media Trend Monitor & OSINT (`thescrapelab/alt-social-narrative-trend-intelligence`) Actor

Monitor public 4chan, Gab, GETTR, Telegram, and Pastebin data. Get evidence-linked narratives, trend scores, source coverage, and fresh OSINT datasets.

- **URL**: https://apify.com/thescrapelab/alt-social-narrative-trend-intelligence.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 narrative 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?

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

## Alternative Social Media Trend Monitor & OSINT

Monitor public conversations across **4chan, Gab, GETTR, Telegram, and Pastebin** and turn fresh posts into an evidence-linked OSINT dataset. This Actor detects related narratives, calculates transparent trend scores, reports source coverage, and preserves links to the public evidence behind every result.

Use it for alternative social media monitoring, emerging-narrative discovery, watchlist research, trust and safety triage, brand-risk analysis, and structured inputs for analyst or AI workflows.

Each run is independent. The Actor starts fresh, never reads previous runs, and does not build a cross-run profile or monitoring history.

### Use cases

- Discover emerging narratives in a bounded sample of current public posts.
- Monitor phrases, hashtags, domains, brands, people, or issues with watchlist queries.
- Compare source breadth across 4chan, Gab, GETTR, Telegram, and Pastebin.
- Rank narratives using volume, engagement, recency, and within-run momentum signals.
- Export normalized evidence with source URLs for investigation and verification.
- Feed structured narrative intelligence into dashboards, reports, alerts, or AI agents.

### Quick start

The default run is deliberately small and cost-controlled. It checks up to five current threads from 4chan's `/g/` board, does not use AI summaries, and normally completes in well under five minutes.

```json
{
  "mode": "discover",
  "sources": ["4chan"],
  "fourchanBoards": ["g"],
  "searchDepth": "quick",
  "includeAiSummaries": false
}
```

For a cross-platform watchlist, provide public accounts or channels for sources that require targets:

```json
{
  "mode": "watchlist",
  "queries": ["example topic", "example.org"],
  "sources": ["gab", "gettr", "telegram", "pastebin"],
  "gabTargets": ["public_username"],
  "gettrUsernames": ["public_username"],
  "telegramChannels": ["public_channel"],
  "searchDepth": "quick",
  "includeEvidenceRows": true
}
```

### Input options

| Field | Description |
| --- | --- |
| `mode` | `discover` groups related records from the fresh sample. `watchlist` keeps evidence matching your queries. |
| `queries` | One to ten phrases, hashtags, or domains. Required in watchlist mode. |
| `sources` | Select any combination of `4chan`, `gab`, `gettr`, `telegram`, and `pastebin`. |
| `fourchanBoards` | Public 4chan board names without slashes. Defaults to `g`. |
| `gabTargets` | Public Gab usernames, profile URLs, or post URLs. Required when collecting from Gab. |
| `gettrUsernames` | Public GETTR usernames. The `@` prefix is optional. |
| `telegramChannels` | Public Telegram channel handles or `t.me` URLs. Private channels are not supported. |
| `lookbackHours` | Keep records within the last 1–168 hours when timestamps are available. |
| `searchDepth` | `quick`, `balanced`, or `deep`, capped at 10, 50, or 200 normalized records per source. |
| `includeEvidenceRows` | Add normalized evidence rows to the dataset. Narrative rows always include evidence IDs. |
| `includeAiSummaries` | Use optional AI-assisted narrative labels and summaries when available. Cluster membership remains deterministic. |
Sources that require a username, URL, or channel are skipped when no target is supplied. Pastebin always uses fresh collection; cumulative indexing and search-engine discovery are disabled.

The Console keeps expert safety controls out of the main form. API clients can optionally set `strictMode` to fail on a source error or `maxUpstreamChargeUsd` to adjust the default $0.05 source-collection ceiling. Both retain safe defaults when omitted.

### Dataset output

The default dataset contains three `recordType` values:

- `narrative` — detected narrative, summary, trend score, score coverage, keywords, contributing sources, and evidence IDs.
- `evidence` — normalized public source record with text, timestamp, engagement, source URL, and narrative ID. Returned when `includeEvidenceRows` is enabled.
- `source_status` — collection status, counts, reported upstream cost, and safe error details for each selected source.

Dataset views are convenient column layouts, not row filters. API clients should filter on `recordType` when they need only narratives, evidence, or source status.

#### Narrative example

```json
{
  "recordType": "narrative",
  "rank": 1,
  "narrativeId": "nar_7dfb68f58c9dc94a",
  "title": "solar · battery · market",
  "summary": "4 fresh evidence items across 2 sources. Activity spans 2026-09-16T10:00:00.000Z to 2026-09-16T11:00:00.000Z. Largest source contribution: gab (3 records).",
  "trendScore": 71.4,
  "scoreCoveragePercent": 90,
  "evidenceCount": 4,
  "sourceCount": 2,
  "sources": ["gab", "gettr"],
  "evidenceIds": ["ev_12b...", "ev_91c..."],
  "evidencePreview": [
    {
      "evidenceId": "ev_12b...",
      "source": "gab",
      "sourceUrl": "https://gab.com/example/posts/123",
      "publishedAt": "2026-09-16T11:00:00.000Z",
      "textSnippet": "Public evidence excerpt supporting this narrative."
    }
  ],
  "keywords": ["solar", "battery", "market"],
  "matchedQueries": [],
  "firstSeenAt": "2026-09-16T10:00:00.000Z",
  "lastSeenAt": "2026-09-16T11:00:00.000Z",
  "sourceBreakdown": {"gab": 3, "gettr": 1},
  "aiEnhanced": false,
  "freshRunOnly": true
}
```

The run also provides these key-value-store records:

- `OUTPUT` — effective settings, top delivered narratives, source results, warnings, timing, billing, and consolidated costs.
- `UPSTREAM_RUNS` — source collection provenance, status, counts, and reported costs.
- `AI_USAGE` — optional AI model, token usage, reported cost, and fallback information.

In `OUTPUT`, `analyzedEvidenceCount` reports all fresh records used for analysis. `deliveredEvidenceRowCount` reports how many separate evidence rows were actually written, and `datasetComposition` provides the delivered narrative, evidence, source-status, and total row counts. This keeps partial pay-per-event runs unambiguous.

### How trend scoring works

Each score uses only signals available in the current run:

- source breadth: 30%
- evidence volume: 25%
- engagement percentile within each source: 20%
- recency inside the requested lookback: 15%
- momentum inside the current run's time window: 10%

`scoreCoveragePercent` shows how much of the scoring model was available. Missing timestamps or engagement values lower coverage rather than silently becoming zero. Momentum compares newer and older portions of the same run window; it does not compare against previous runs.

### Pricing and cost controls

The Actor uses pay-per-event pricing:

- **$0.01 per delivered narrative result**
- **$0.00005 Actor start charge**
- no separate charge for evidence or source-status rows

Apify's maximum run-cost setting is respected. If the remaining limit cannot cover every generated narrative, the Actor delivers only paid narratives and their matching evidence, then reports the result as partial. Optional AI work is limited to narratives that can be delivered.

Upstream source collection is separately protected by a default $0.05 ceiling and a stricter operator maximum. The inexpensive default uses one source, quick depth, no full evidence rows, and no AI summary.

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor(
    "thescrapelab/alt-social-narrative-trend-intelligence"
).call(
    run_input={
        "mode": "discover",
        "sources": ["4chan"],
        "fourchanBoards": ["g"],
        "searchDepth": "quick",
        "includeEvidenceRows": True,
        "includeAiSummaries": False,
    },
    max_total_charge_usd=0.10,
)

dataset = client.dataset(run["defaultDatasetId"])
for item in dataset.iterate_items():
    if item["recordType"] == "narrative":
        print(item["title"], item["trendScore"], item["sources"])
```

You can also run the Actor from Apify Console and download results as JSON, CSV, Excel, XML, RSS, or JSONL from the Dataset tab.

### Privacy and responsible use

- The Actor processes public source material only.
- Every run starts fresh and does not consult previous Actor runs.
- It creates no named dataset, cache, task, schedule, webhook, or background monitor.
- Optional AI sends bounded excerpts of public evidence—up to eight 350-character excerpts for each of at most five deliverable narratives—to OpenRouter for labeling and summarization.
- AI cannot merge or split deterministic clusters and must cite existing evidence IDs.
- If AI is unavailable, deterministic narrative results are still returned.

Use source URLs and evidence rows to verify important findings. Follow applicable laws, platform terms, privacy obligations, and your organization's policies when using public data.

### Limitations

- Results represent the bounded public records collected in one run, not population-level prevalence.
- Public sources may be unavailable, incomplete, deleted, rate-limited, or change their interfaces.
- Engagement values differ by platform, so engagement ranking is calculated within each source.
- Records without usable timestamps can remain eligible but reduce score coverage.
- Discover mode finds patterns only within the selected sources and search depth.
- The Actor does not identify coordinated behavior, intent, truthfulness, or causation.

### Troubleshooting and support

- A `skipped` source usually needs a public username, URL, or Telegram channel.
- An empty watchlist result means the bounded fresh sample did not contain the query. Add relevant targets or increase search depth deliberately.
- Partial results remain usable. Review `source_status` rows and `UPSTREAM_RUNS` before retrying.
- If AI was requested but not used, review `AI_USAGE`; deterministic narratives remain available.

For reproducible support, include the Actor run ID, selected sources, non-sensitive input settings, and the affected `source_status` row. Never include API tokens or private credentials.

# Changelog

This Actor's version history is a separate document: https://apify.com/thescrapelab/alt-social-narrative-trend-intelligence/changelog.md

# Actor input Schema

## `mode` (type: `string`):

Discover clusters the bounded fresh sample; watchlist keeps evidence matching your queries.

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

Required in watchlist mode. Use one to ten phrases, hashtags, or domains.

## `sources` (type: `array`):

Only selected sources launch child runs. The low-cost default runs five fresh 4chan threads only.

## `fourchanBoards` (type: `array`):

Public 4chan board names without slashes. Quick runs inspect at most five threads in total.

## `gabTargets` (type: `array`):

Optional public Gab usernames, profile URLs, or direct post URLs.

## `gettrUsernames` (type: `array`):

Optional public GETTR usernames; the @ prefix is not required.

## `telegramChannels` (type: `array`):

Public Telegram channel handles or t.me URLs. Private channels are not supported.

## `lookbackHours` (type: `integer`):

Filter normalized evidence to this many hours when source timestamps are available.

## `searchDepth` (type: `string`):

Cap normalized collection at 10, 50, or 200 records per source; quick 4chan runs use five threads.

## `includeEvidenceRows` (type: `boolean`):

Narrative rows always cite evidence IDs. Enable this to also write normalized evidence as separate dataset rows.

## `includeAiSummaries` (type: `boolean`):

Requires the Actor's encrypted OPENROUTER\_API\_KEY secret. AI cannot change cluster membership and falls back safely if unavailable.

## `strictMode` (type: `boolean`):

Advanced API control. The safe default returns useful partial results when one source fails or times out.

## `maxUpstreamChargeUsd` (type: `number`):

Advanced API control. The default allows up to $0.05 across source collection runs and remains subject to the operator ceiling.

## Actor input object example

```json
{
  "mode": "discover",
  "queries": [],
  "sources": [
    "4chan"
  ],
  "fourchanBoards": [
    "g"
  ],
  "gabTargets": [],
  "gettrUsernames": [],
  "telegramChannels": [],
  "lookbackHours": 24,
  "searchDepth": "quick",
  "includeEvidenceRows": false,
  "includeAiSummaries": false,
  "strictMode": false,
  "maxUpstreamChargeUsd": 0.05
}
```

# Actor output Schema

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

Open the complete fresh-run dataset of narrative, evidence, and source-status records. Filter integrations by recordType.

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

Open the effective settings, top delivered narratives, analyzed-versus-delivered evidence counts, dataset composition, source results, warnings, timing, billing, and consolidated cost totals.

## `upstreamRuns` (type: `string`):

Review the provenance, status, counts, and reported costs for source Actors launched during this run.

## `aiUsage` (type: `string`):

Review optional AI status, model, token counts, reported cost credits, and deterministic fallback reason.

# 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 = {
    "mode": "discover",
    "sources": [
        "4chan"
    ],
    "fourchanBoards": [
        "g"
    ],
    "searchDepth": "quick"
};

// Run the Actor and wait for it to finish
const run = await client.actor("thescrapelab/alt-social-narrative-trend-intelligence").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 = {
    "mode": "discover",
    "sources": ["4chan"],
    "fourchanBoards": ["g"],
    "searchDepth": "quick",
}

# Run the Actor and wait for it to finish
run = client.actor("thescrapelab/alt-social-narrative-trend-intelligence").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 '{
  "mode": "discover",
  "sources": [
    "4chan"
  ],
  "fourchanBoards": [
    "g"
  ],
  "searchDepth": "quick"
}' |
apify call thescrapelab/alt-social-narrative-trend-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thescrapelab/alt-social-narrative-trend-intelligence"
        }
    }
}
```

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/HZ8Z2so2aicFsa5TZ/builds/ublQyhX9ZnIxEmsHv/openapi.json