# GMGN Crypto KOL Twitter & Telegram Signal Feed (`logiover/gmgn-crypto-kol-twitter-telegram-feed`) Actor

Live feed of crypto KOL Twitter activity (tweets, reposts, quotes, profile changes) and Telegram channel calls from GMGN.ai. Each event tagged by user category (KOL, trader, founder, exchange, celebrity), follower count, content + translation, source tweet, and token address discussed.

- **URL**: https://apify.com/logiover/gmgn-crypto-kol-twitter-telegram-feed.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Social media, Automation, News
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## GMGN Crypto KOL Twitter & Telegram Signal Feed — Real-time Influencer & Channel Calls

![GMGN Crypto KOL Twitter & Telegram Signal Feed](https://apify-image-uploads-prod.s3.us-east-1.amazonaws.com/GjS6nQ8qauOdq9KGy-actor-ftK2UUvvUk3b53Clg-To9rh5nl3s-images.png)

**The fastest alpha feed on Apify.** This actor pulls GMGN.ai's curated KOL Twitter activity (tweets, reposts, quotes, replies, follows, banner / handle / name / description changes) AND Telegram channel signals — all tagged, structured, and ready to ingest into your bot / dashboard / newsletter.

> Every event comes pre-classified by user category (KOL, trader, exchange, celebrity, politics, media, founder, Binance Square, exchange-listing), with full content + auto-translation, source tweet, follower count, and (when relevant) the **token address being discussed**.

---

### 🚀 What this actor does

GMGN.ai monitors thousands of curated crypto Twitter accounts and Telegram channels in real time. Their backend tags every event with `user_tags` (account category) and the token being referenced (parsed from cashtags, contract addresses, etc.). This actor exposes the two raw feeds:

- **`/vas/api/v1/twitter/messages`** — Twitter activity feed with rich filtering.
- **`/vas/api/v1/tg/messages`** — Telegram channel signals (each tagged with win-rate, member count, mcap, current price).

Run it once → get the most recent snapshot. Run it with `pollIterations: 120` and `pollIntervalSec: 30` → 60-minute continuous live feed within a single Apify run.

---

### 💡 Use cases

- **Alpha-feed Telegram / Discord bot** — webhook every KOL tweet that mentions a token into your private signal channel.
- **Sentiment tracking** — collect KOL chatter over weeks; map mentions to price action.
- **AI training** — labelled dataset of KOL posts × token outcomes for predicting price impact.
- **Influencer accountability** — track when public figures pump / dump tokens.
- **Listing watch** — `user_tags: ["exchange", "binance_square", "exchange_listing"]` to be first to know about listings.
- **News dashboard** — surface real-time KOL reactions to events.
- **Channel discovery** — Telegram feed surfaces channel `win_rate` and `members_count` — ideal for vetting alpha channels.
- **Anti-pump-and-dump detection** — when an account renames, deletes posts, or changes handle, GMGN exposes those events too.

---

### ⚙️ Input configuration

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `feeds` | `string[]` | `["twitter","telegram"]` | Pick `twitter`, `telegram`, or both. |
| `userTags` | `string[]` | curated set | Twitter user categories. Leave empty for all. |
| `twTypes` | `string[]` | `["tweet","repost","quote","reply","pin"]` | Twitter event types. |
| `hasToken` | `boolean` | `false` | Keep only Twitter posts with a parsed token contract. |
| `featuredOnly` | `boolean` | `false` | GMGN curated featured items only. |
| `mineOnly` | `boolean` | `false` | Try `mine=1` (needs auth — generally leave OFF). |
| `tgFeatured` | `boolean` | `false` | Telegram featured-only. |
| `tgLimit` | `integer` | `30` | Telegram messages per call (max 30). |
| `pollIterations` | `integer` | `1` | How many polls within a single run. |
| `pollIntervalSec` | `integer` | `30` | Seconds between polls (when iterations > 1). |
| `deduplicate` | `boolean` | `true` | Skip items already seen this run. |
| `useProxy` | `boolean` | `true` | |
| `proxyConfiguration` | `object` | residential | |
| `maxConcurrency` | `integer` | `2` | |

#### Twitter user_tags vocabulary

| Tag | Who it covers |
|-----|---------------|
| `kol` | Key opinion leader. |
| `trader` | Pro trader / fund. |
| `master` | Crypto OG / master. |
| `founder` | Project founder / team. |
| `exchange` | Exchange official accounts. |
| `celebrity` | Mainstream celebrity. |
| `politics` | Political figures. |
| `media` | Crypto media outlets. |
| `companies` | Listed crypto companies. |
| `binance_square` | Binance Square posts. |
| `exchange_listing` | Listing-announcement accounts. |
| `other` | Other curated. |

#### Twitter tw_types vocabulary

| Type | Meaning |
|------|---------|
| `tweet` | Original tweet. |
| `repost` | Retweet. |
| `quote` | Quote-tweet. |
| `reply` | Reply. |
| `delete_post` | Tweet deletion event. |
| `pin` / `unpin` | Pinning a tweet. |
| `follow` / `unfollow` | Following events (rare). |
| `banner` / `photo` | Profile media change. |
| `name` / `handle` / `description` | Profile-text change. |

---

### 📦 Output rows

Two row kinds distinguished by `_kind`.

#### `twitter`
| Field | Description |
|-------|-------------|
| `platform` | `twitter`. |
| `twType` | Event type. |
| `tweetId`, `sourceId` | Tweet IDs. |
| `userTwitterId`, `userScreenName`, `userName`, `userAvatar`, `userFollowers`, `userVerified` | Author. |
| `userTags` | GMGN tag list. |
| `sourceUserTwitterId`, `sourceUserScreenName`, `sourceUserName`, `sourceUserFollowers` | Source account (for reposts / quotes). |
| `sourceContent` | Raw tweet text. |
| `translationZh` | Auto-translation to Chinese. |
| `chain`, `tokenAddress`, `tokenSymbol`, `tokenLogo`, `price`, `mcap` | Token tagged (when applicable). |
| `twTimestamp`, `twTimestampMs` | When the tweet was posted. |
| `tweetUrl`, `userProfileUrl` | Convenience links. |
| `scrapedAt` | |

#### `telegram`
| Field | Description |
|-------|-------------|
| `platform` | `telegram`. |
| `channelId`, `channelName`, `channelUsername`, `channelAvatar`, `channelUrl` | Channel identity. |
| `channelMembersCount`, `channelWinRate` | Channel metadata. |
| `messageId`, `messageSendAt`, `messageSendAtUnix` | Message identity & time. |
| `content` | Message content. |
| `chain`, `tokenAddress`, `tokenSymbol`, `tokenLogo`, `price`, `price24h`, `mcap` | Token tagged. |
| `featured` | Featured flag. |
| `scrapedAt` | |

---

### 🧪 Example output (twitter)

```json
{
  "_kind": "twitter",
  "platform": "twitter",
  "twType": "repost",
  "tweetId": "2055258017877090314",
  "userScreenName": "MindMatterMoney",
  "userName": "Leon",
  "userFollowers": 261424,
  "userVerified": false,
  "userTags": ["kol"],
  "sourceUserScreenName": "LumenX_",
  "sourceContent": "\"I will give you back seven times what you lost.\" Joel 2:25.\n\nIf you believe type 'Amen'.",
  "translationZh": "「我必七倍偿还你所失去的。」约珥书 2:25\n\n如果你相信，请回复\"阿门\"。",
  "twTimestamp": "2026-05-15T12:04:30.966Z",
  "tweetUrl": "https://x.com/MindMatterMoney/status/2055258017877090314",
  "userProfileUrl": "https://x.com/MindMatterMoney",
  "scrapedAt": "2026-05-15T12:05:00.000Z"
}
````

### 🧪 Example output (telegram)

```json
{
  "_kind": "telegram",
  "platform": "telegram",
  "channelId": "-1001664356761",
  "channelName": "Rich Duck Calls",
  "channelUsername": "richduckofficial",
  "channelMembersCount": 3966,
  "channelWinRate": 0.42,
  "channelUrl": "https://t.me/richduckofficial/19653",
  "messageId": "20607664128",
  "messageSendAt": "2026-05-15T12:02:20.000Z",
  "content": "$DIAMOND\n\n85k\n\n8Kpqq6791DvdomkV59DXMqRXvoh3k6wM6nbFNkcBpump",
  "chain": "sol",
  "tokenAddress": "8Kpqq6791DvdomkV59DXMqRXvoh3k6wM6nbFNkcBpump",
  "tokenSymbol": "DIAMOND",
  "price": 0.000189,
  "price24h": 0.0000026,
  "mcap": 15.74,
  "featured": false,
  "scrapedAt": "2026-05-15T12:05:00.000Z"
}
```

***

### 🧰 Recipes

#### 1. Live KOL alpha feed (60 min run)

```json
{
  "feeds": ["twitter"],
  "userTags": ["kol", "master", "trader"],
  "twTypes": ["tweet", "quote"],
  "hasToken": true,
  "pollIterations": 60,
  "pollIntervalSec": 60
}
```

Polls every 60 seconds for 60 minutes. Skips duplicates. Webhook every new tweet to your alpha channel.

#### 2. Exchange listing watcher

```json
{
  "feeds": ["twitter"],
  "userTags": ["exchange", "binance_square", "exchange_listing"],
  "twTypes": ["tweet", "quote", "pin"]
}
```

#### 3. Profile change / scam-detection feed

```json
{
  "feeds": ["twitter"],
  "userTags": ["founder"],
  "twTypes": ["name", "handle", "description", "banner", "delete_post"]
}
```

Surfaces project founders renaming Twitter or deleting posts — strong scam signal.

#### 4. Telegram alpha channels with high win-rate

Run with `feeds: ["telegram"]`, then filter the dataset to `channelWinRate > 0.5` and `channelMembersCount > 1000`.

#### 5. Daily archive

Run with `pollIterations: 1` once per day, schedule on Apify. Builds a long-term archive of KOL chatter for ML training.

***

### 🛡️ Under the hood

- **Endpoints** —
  - `GET /vas/api/v1/twitter/messages?has_token=&user_tags=&tw_types=&featured=&mine=`
  - `GET /vas/api/v1/tg/messages?limit=30&featured=`
- **Polling** — built-in iteration with deduplication via in-memory ID set.
- **Auth** — none (Cloudflare-fronted, fingerprint-gated).
- **Proxy** — Apify Residential default.
- **Retries** — 5 attempts with exponential backoff on 403 / 429 / 5xx.

***

### ⚡ Performance

| Configuration | Rows | Time | Cost |
|--------------|------|------|------|
| Single poll, both feeds | 50-150 | ~10s | <$0.01 |
| 30 polls × 30s (15 min) | 200-1000 | ~15 min | ~$0.03 |
| 60 polls × 60s (60 min) | 500-3000 | ~60 min | ~$0.08 |

***

### 📅 Recommended schedules

- **Continuous live feed** — `pollIterations: 60, pollIntervalSec: 60` for hour-long runs scheduled every hour.
- **Hourly snapshot** — single poll every hour.
- **Daily archive** — single poll once per day.

***

### ❓ FAQ

#### How does GMGN classify KOLs?

GMGN curates a list of ~10k crypto Twitter accounts and tags them by `user_tags`. The classification is internal but stable.

#### Does this give me EVERY tweet from KOLs?

GMGN's feed is a cursor-less most-recent-N feed. Polling continuously catches everything new without misses. The feed depth is ~50-100 most-recent items per call.

#### Why are some tweets in Chinese?

GMGN was founded by Chinese-speaking devs; `translation.zh-CN` is provided alongside originals.

#### How is `hasToken` determined?

GMGN parses the tweet for cashtags and contract addresses, then resolves to a chain + token. Only matches set `tokenAddress`.

#### What's `channelWinRate` on Telegram?

GMGN tracks each channel's signal calls and computes a public win rate (0-1). Above 0.5 = better than coin-flip.

#### Can I filter by specific KOL usernames?

Not directly — but post-process the dataset by `userScreenName`. To monitor a specific user only, see Apify's Twitter Scraper actors.

#### How do I get a live webhook for every new tweet?

Use Apify's webhook integrations — each `pushData` triggers a webhook with the new rows.

#### Why are profile-change events (`name`, `handle`, ...) useful?

Scam projects often rename / delete posts to cover their tracks. Watching `delete_post` events on `userTags: ["founder"]` accounts is a strong scam signal.

#### Does it catch deleted tweets?

Yes — `tw_type: "delete_post"` is emitted with the original `tweet_id` reference.

#### Can I scrape historical KOL feeds?

GMGN only exposes current state. To build history, schedule the actor regularly and archive results.

#### What if a tweet has no `sourceContent`?

For pure profile-change events (banner / handle / name), `sourceContent` may be empty — the event itself is the signal.

***

### 🔗 Related actors

- **GMGN Trending Memecoin Scanner** — pair with this to find which tokens KOLs are talking about.
- **GMGN Smart Money Buy Signals** — correlate KOL tweets with on-chain whale activity.
- **GMGN Token Holders Intelligence** — see if KOLs themselves are holding the tokens they shill.
- **GMGN New Token Launch Detector** — fresh launches first heard about on Twitter.
- **GMGN Wallet Portfolio & PnL Tracker** — audit a KOL's actual PnL.
- **GMGN Smart Money Wallet Leaderboard** — top traders.
- **GMGN Token Rugcheck & Deep Analytics** — security audit per token.

***

### 🆘 Support

Bug? Want a new user-tag exposed? Open an issue on the actor's Apify page.

# Actor input Schema

## `feeds` (type: `array`):

Which GMGN feeds to scrape. 'twitter' = KOL Twitter activity. 'telegram' = Telegram channel signals. Both together gives the broadest alpha coverage.

## `userTags` (type: `array`):

Which user categories to include in the Twitter feed. Leave empty for ALL categories. Possible values: kol, trader, master, politics, media, companies, founder, exchange, celebrity, binance\_square, exchange\_listing, other.

## `twTypes` (type: `array`):

Which Twitter event types to keep. Examples: tweet (original post), repost, quote, reply, delete\_post, follow, unfollow, banner (avatar change), name / handle / description / photo (profile updates), pin / unpin.

## `hasToken` (type: `boolean`):

When ON, keep only Twitter posts where GMGN matched a token contract from the content (cashtag, contract address, etc.).

## `featuredOnly` (type: `boolean`):

When ON, GMGN returns only featured / curated items.

## `mineOnly` (type: `boolean`):

When ON, GMGN tries to return only items relevant to the authenticated user. Without auth this generally returns nothing — leave OFF unless you've extended the actor with cookies.

## `tgFeatured` (type: `boolean`):

Telegram counterpart of `featuredOnly`.

## `tgLimit` (type: `integer`):

Telegram messages per call (max 30 per call observed).

## `pollIterations` (type: `integer`):

How many times to re-poll each feed in a single run, waiting `pollIntervalSec` between iterations. 1 = fetch once and exit. Higher = more rows (each iter captures new items). Default 30 = ~15 minutes of feed monitoring with the default 30s interval.

## `pollIntervalSec` (type: `integer`):

Seconds to wait between polls when `pollIterations > 1`.

## `deduplicate` (type: `boolean`):

When ON, items already seen in earlier polls of the same run are skipped. Recommended when using `pollIterations > 1`.

## `useProxy` (type: `boolean`):

Route requests through Apify Proxy. Strongly recommended ON — residential proxy is the most reliable way to bypass Cloudflare rate limits.

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

Apify Proxy configuration. Residential proxy group is recommended for the highest success rate against Cloudflare.

## `maxConcurrency` (type: `integer`):

Maximum number of API calls running in parallel. Higher = faster runs but more chance of hitting rate limits. 3-5 is safe.

## Actor input object example

```json
{
  "feeds": [
    "twitter",
    "telegram"
  ],
  "userTags": [
    "kol",
    "trader",
    "master",
    "politics",
    "media",
    "companies",
    "founder",
    "exchange",
    "celebrity",
    "binance_square",
    "exchange_listing",
    "other"
  ],
  "twTypes": [
    "tweet",
    "repost",
    "quote",
    "reply",
    "delete_post",
    "pin",
    "unpin",
    "follow",
    "unfollow",
    "banner",
    "photo",
    "name",
    "handle",
    "description"
  ],
  "hasToken": false,
  "featuredOnly": false,
  "mineOnly": false,
  "tgFeatured": false,
  "tgLimit": 30,
  "pollIterations": 30,
  "pollIntervalSec": 30,
  "deduplicate": true,
  "useProxy": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 2
}
```

# Actor output Schema

## `_kind` (type: `string`):

twitter or telegram

## `platform` (type: `string`):

twitter or telegram

## `twType` (type: `string`):

tweet, repost, quote, reply, name, etc.

## `tweetId` (type: `string`):

Tweet ID

## `userScreenName` (type: `string`):

Twitter screen name

## `userName` (type: `string`):

Display name

## `userFollowers` (type: `string`):

User follower count

## `userVerified` (type: `string`):

Blue-verified flag

## `userTags` (type: `string`):

KOL / trader / founder / etc.

## `sourceUserScreenName` (type: `string`):

Source screen name (repost/quote/reply)

## `sourceUserFollowers` (type: `string`):

Source user follower count

## `sourceContent` (type: `string`):

Tweet content

## `translationZh` (type: `string`):

Chinese auto-translation

## `chain` (type: `string`):

Blockchain (when token tagged)

## `tokenAddress` (type: `string`):

Token contract address

## `tokenSymbol` (type: `string`):

Token symbol

## `price` (type: `string`):

Token price USD

## `mcap` (type: `string`):

Token market cap

## `twTimestamp` (type: `string`):

ISO tweet timestamp

## `tweetUrl` (type: `string`):

Direct tweet URL

## `userProfileUrl` (type: `string`):

User profile URL

## `channelId` (type: `string`):

Telegram channel ID

## `channelName` (type: `string`):

Telegram channel name

## `channelUsername` (type: `string`):

Telegram channel username

## `channelUrl` (type: `string`):

Telegram message URL

## `channelMembersCount` (type: `string`):

Channel member count

## `channelWinRate` (type: `string`):

Channel signal win rate 0-1

## `messageSendAt` (type: `string`):

ISO message timestamp

## `content` (type: `string`):

Telegram message content

## `price24h` (type: `string`):

Token price 24h ago (telegram rows)

## `featured` (type: `string`):

Featured flag

## `scrapedAt` (type: `string`):

Scrape timestamp

# 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("logiover/gmgn-crypto-kol-twitter-telegram-feed").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("logiover/gmgn-crypto-kol-twitter-telegram-feed").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 logiover/gmgn-crypto-kol-twitter-telegram-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=logiover/gmgn-crypto-kol-twitter-telegram-feed",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GMGN Crypto KOL Twitter & Telegram Signal Feed",
        "description": "Live feed of crypto KOL Twitter activity (tweets, reposts, quotes, profile changes) and Telegram channel calls from GMGN.ai. Each event tagged by user category (KOL, trader, founder, exchange, celebrity), follower count, content + translation, source tweet, and token address discussed.",
        "version": "1.0",
        "x-build-id": "WVScnykewn0B2VfoL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~gmgn-crypto-kol-twitter-telegram-feed/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-gmgn-crypto-kol-twitter-telegram-feed",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/logiover~gmgn-crypto-kol-twitter-telegram-feed/runs": {
            "post": {
                "operationId": "runs-sync-logiover-gmgn-crypto-kol-twitter-telegram-feed",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/logiover~gmgn-crypto-kol-twitter-telegram-feed/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-gmgn-crypto-kol-twitter-telegram-feed",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "feeds": {
                        "title": "Feeds to Scrape",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which GMGN feeds to scrape. 'twitter' = KOL Twitter activity. 'telegram' = Telegram channel signals. Both together gives the broadest alpha coverage.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "twitter",
                                "telegram"
                            ],
                            "enumTitles": [
                                "Twitter (KOL feed)",
                                "Telegram (channels)"
                            ]
                        },
                        "default": [
                            "twitter",
                            "telegram"
                        ]
                    },
                    "userTags": {
                        "title": "Twitter User Tags",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which user categories to include in the Twitter feed. Leave empty for ALL categories. Possible values: kol, trader, master, politics, media, companies, founder, exchange, celebrity, binance_square, exchange_listing, other.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "kol",
                                "trader",
                                "master",
                                "politics",
                                "media",
                                "companies",
                                "founder",
                                "exchange",
                                "celebrity",
                                "binance_square",
                                "exchange_listing",
                                "other"
                            ],
                            "enumTitles": [
                                "KOL",
                                "Trader",
                                "Master",
                                "Politics",
                                "Media",
                                "Companies",
                                "Founder",
                                "Exchange",
                                "Celebrity",
                                "Binance Square",
                                "Exchange Listing",
                                "Other"
                            ]
                        },
                        "default": [
                            "kol",
                            "trader",
                            "master",
                            "politics",
                            "media",
                            "companies",
                            "founder",
                            "exchange",
                            "celebrity",
                            "binance_square",
                            "exchange_listing",
                            "other"
                        ]
                    },
                    "twTypes": {
                        "title": "Twitter Event Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which Twitter event types to keep. Examples: tweet (original post), repost, quote, reply, delete_post, follow, unfollow, banner (avatar change), name / handle / description / photo (profile updates), pin / unpin.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "tweet",
                                "repost",
                                "quote",
                                "reply",
                                "delete_post",
                                "pin",
                                "unpin",
                                "follow",
                                "unfollow",
                                "banner",
                                "photo",
                                "name",
                                "handle",
                                "description"
                            ],
                            "enumTitles": [
                                "Tweet",
                                "Repost",
                                "Quote",
                                "Reply",
                                "Delete Post",
                                "Pin",
                                "Unpin",
                                "Follow",
                                "Unfollow",
                                "Banner Change",
                                "Photo Change",
                                "Name Change",
                                "Handle Change",
                                "Description Change"
                            ]
                        },
                        "default": [
                            "tweet",
                            "repost",
                            "quote",
                            "reply",
                            "delete_post",
                            "pin",
                            "unpin",
                            "follow",
                            "unfollow",
                            "banner",
                            "photo",
                            "name",
                            "handle",
                            "description"
                        ]
                    },
                    "hasToken": {
                        "title": "Only Token-Tagged Tweets",
                        "type": "boolean",
                        "description": "When ON, keep only Twitter posts where GMGN matched a token contract from the content (cashtag, contract address, etc.).",
                        "default": false
                    },
                    "featuredOnly": {
                        "title": "Featured Only",
                        "type": "boolean",
                        "description": "When ON, GMGN returns only featured / curated items.",
                        "default": false
                    },
                    "mineOnly": {
                        "title": "Mine Only (authenticated)",
                        "type": "boolean",
                        "description": "When ON, GMGN tries to return only items relevant to the authenticated user. Without auth this generally returns nothing — leave OFF unless you've extended the actor with cookies.",
                        "default": false
                    },
                    "tgFeatured": {
                        "title": "Telegram Featured Only",
                        "type": "boolean",
                        "description": "Telegram counterpart of `featuredOnly`.",
                        "default": false
                    },
                    "tgLimit": {
                        "title": "Telegram Limit per Call",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Telegram messages per call (max 30 per call observed).",
                        "default": 30
                    },
                    "pollIterations": {
                        "title": "Poll Iterations",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "How many times to re-poll each feed in a single run, waiting `pollIntervalSec` between iterations. 1 = fetch once and exit. Higher = more rows (each iter captures new items). Default 30 = ~15 minutes of feed monitoring with the default 30s interval.",
                        "default": 30
                    },
                    "pollIntervalSec": {
                        "title": "Poll Interval (seconds)",
                        "minimum": 5,
                        "maximum": 3600,
                        "type": "integer",
                        "description": "Seconds to wait between polls when `pollIterations > 1`.",
                        "default": 30
                    },
                    "deduplicate": {
                        "title": "Deduplicate Across Polls",
                        "type": "boolean",
                        "description": "When ON, items already seen in earlier polls of the same run are skipped. Recommended when using `pollIterations > 1`.",
                        "default": true
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify Proxy. Strongly recommended ON — residential proxy is the most reliable way to bypass Cloudflare rate limits.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify Proxy configuration. Residential proxy group is recommended for the highest success rate against Cloudflare.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrent Requests",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Maximum number of API calls running in parallel. Higher = faster runs but more chance of hitting rate limits. 3-5 is safe.",
                        "default": 2
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
