# Trends MCP - Social Listening (`trendsmcp/trendsmcp-mcp`) Actor

MCP server giving AI agents trend data across Google Search, YouTube, TikTok, Amazon, Reddit, Wikipedia, Steam, npm, news sentiment, and 25+ live feeds. Powered by trendsmcp.ai.

- **URL**: https://apify.com/trendsmcp/trendsmcp-mcp.md
- **Developed by:** [TrendsMCP 25+ data sources, one connection](https://apify.com/trendsmcp) (community)
- **Categories:** AI, Social media, MCP servers
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## Trends MCP — Live Trend Data for AI Agents

**One MCP server. 25+ data sources. Ask your AI what's breaking out across search, social, and commerce.**

Connect any MCP-compatible AI (Claude, Cursor, ChatGPT, Windsurf, VS Code Copilot) to live trend data with a single API key.

**[Get your free API key at trendsmcp.ai](https://trendsmcp.ai)** — 100 requests/month, no credit card.

---

### What Trends MCP does

Trends MCP gives AI agents access to normalized trend data across 25+ keyword sources and live feeds — Google Search, YouTube, TikTok, Amazon, Reddit, Wikipedia, Steam, npm, news sentiment, and more.

Instead of juggling per-platform keys, scrapers, and rate limits, your AI calls three tools and gets back clean JSON:

| Tool | What it does |
|---|---|
| `get_trends` | ~5 years of weekly time-series data for any keyword, normalized 0–100 |
| `get_growth` | % change over preset or custom periods (7D, 1M, 3M, 6M, 1Y, YTD, ...) across one or many sources at once |
| `get_top_trends` | What's trending right now — no keyword needed. Google Trends, TikTok, Reddit, YouTube, Amazon, Spotify, GitHub, and more |

---

### Connect to your AI in 30 seconds

The fastest way to connect is directly — no Actor needed.

#### Step 1 — Get your free API key

Sign up at **[trendsmcp.ai](https://trendsmcp.ai)**. Your key arrives by email instantly. Free tier: 100 requests/month, no credit card.

#### Step 2 — Add to your AI client

##### Cursor / Windsurf / VS Code

Add to your MCP config:

```json
"trends-mcp": {
  "url": "https://api.trendsmcp.ai/mcp",
  "transport": "http",
  "headers": { "Authorization": "Bearer YOUR_TRENDS_API_KEY" }
}
````

##### Claude Desktop

Add to `claude_desktop_config.json` inside `mcpServers`:

```json
"trends-mcp": {
  "command": "npx",
  "args": [
    "-y",
    "mcp-remote",
    "https://api.trendsmcp.ai/mcp",
    "--header",
    "Authorization:${AUTH_HEADER}"
  ],
  "env": {
    "AUTH_HEADER": "Bearer YOUR_TRENDS_API_KEY"
  }
}
```

##### Claude.ai (browser)

Go to Settings → Customize → Connectors → Add custom connector. Use:

```
https://www.trendsmcp.ai/mcp
```

Full setup instructions for every client at **[trendsmcp.ai/docs](https://trendsmcp.ai/docs)**.

***

### Keyword sources

Pass the `source` value with `get_trends` or `get_growth`. All values normalized to a 0–100 index for cross-platform comparison.

| source | Description | Keyword format |
|---|---|---|
| `google search` | Google search volume | Any keyword or phrase |
| `google images` | Google image search volume | Any keyword or phrase |
| `google news` | Google News search volume | Any keyword or phrase |
| `google shopping` | Google Shopping search volume | Any keyword or phrase |
| `youtube` | YouTube search volume | Any keyword or phrase |
| `tiktok` | TikTok hashtag volume | Hashtag or topic |
| `reddit` | Subreddit subscriber count | Subreddit name, no `r/` prefix |
| `amazon` | Amazon product search volume | Product name or category |
| `wikipedia` | Wikipedia page views | Article title or topic |
| `news volume` | News article mention volume | Any keyword or phrase |
| `news sentiment` | News sentiment score (positive/negative) | Any keyword or phrase |
| `app downloads` | Android app download estimates (AppBrain) | Android bundle ID e.g. `com.openai.chatgpt` |
| `app rankings` | Android app store ranking charts | Android bundle ID |
| `npm` | npm package weekly downloads | Exact package name e.g. `react`, `@babel/core` |
| `steam` | Steam concurrent players (monthly) | Game display name e.g. `Elden Ring` |

***

### Live feeds

Use `get_top_trends` with one of these `type` values. No keyword needed.

| type | Feed |
|---|---|
| `Google Trends` | Top trending searches on Google right now |
| `Google News Top News` | Top stories from Google News |
| `TikTok Trending Hashtags` | Top trending hashtags on TikTok |
| `YouTube Trending` | Top trending videos on YouTube |
| `X (Twitter) Trending` | Top trending topics on X |
| `Reddit Hot Posts` | Hottest posts on Reddit's front page |
| `Reddit World News` | Top posts in r/worldnews |
| `Wikipedia Trending` | Most-viewed Wikipedia articles today |
| `Amazon Best Sellers Top Rated` | Amazon top-rated best sellers |
| `Amazon Best Sellers by Category` | Amazon best sellers by category |
| `App Store Top Free` | Top free iOS apps |
| `App Store Top Paid` | Top paid iOS apps |
| `Google Play` | Top apps on Google Play |
| `Top Websites` | Most-visited websites globally |
| `Spotify Top Podcasts` | Top podcasts on Spotify |
| `Steam Most Played` | Top games by concurrent live players |
| `GitHub Trending Repos` | Daily trending repos across all languages |
| `IMDb MOVIEmeter` | Top 100 most-popular movies by user activity |
| `Open Library Trending Books` | Daily trending books from Open Library |

***

### Example prompts for your AI

Once connected, you can ask your AI things like:

- *"What is the 12-month growth for 'GLP-1 drugs' across Google Search, TikTok, and Amazon?"*
- *"Show me the Wikipedia page view trend for 'artificial intelligence' over the last 5 years."*
- *"What's trending on TikTok and Reddit right now?"*
- *"Compare the 3-month growth of 'creatine gummies' on Google Search vs YouTube vs Amazon."*
- *"Get the top 20 GitHub trending repos today."*
- *"What are the top free iOS apps in the App Store right now?"*
- *"How has Steam player count for 'Elden Ring' changed over the past year?"*

***

### Growth presets

Use any of these with `get_growth`'s `percent_growth` array:

`7D` `14D` `30D` `1M` `2M` `3M` `6M` `9M` `12M` `1Y` `18M` `24M` `2Y` `36M` `3Y` `48M` `60M` `5Y` `MTD` `QTD` `YTD`

Or pass a custom date pair:

```json
{ "name": "launch", "recent": "2025-06-01", "baseline": "2025-01-01" }
```

***

### Pricing

| Plan | Requests/month | Price |
|---|---|---|
| Free | 100 | $0 — no credit card |
| Starter | 1,000 | $19/month |
| Pro | 5,000 | $49/month |
| Business | 25,000 | $199/month |

One request = one API call. `get_growth` counts once regardless of how many periods you pass. Annual billing saves 20%.

**[Get your free API key at trendsmcp.ai](https://trendsmcp.ai)**

***

### About Trends MCP

Trends MCP is an independent analytics service. Values are normalized proprietary estimates produced through aggregation and modeling of publicly observable signals — not official platform metrics. See [trendsmcp.ai](https://trendsmcp.ai) for full terms.

**Links:** [trendsmcp.ai](https://trendsmcp.ai) · [Docs](https://trendsmcp.ai/docs) · [Pricing](https://trendsmcp.ai/pricing)

# Actor input Schema

## `trendsApiKey` (type: `string`):

Your API key from trendsmcp.ai. Get one free at https://trendsmcp.ai

## Actor input object example

```json
{}
```

# 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("trendsmcp/trendsmcp-mcp").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("trendsmcp/trendsmcp-mcp").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 trendsmcp/trendsmcp-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trendsmcp/trendsmcp-mcp",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trends MCP - Social Listening",
        "description": "MCP server giving AI agents trend data across Google Search, YouTube, TikTok, Amazon, Reddit, Wikipedia, Steam, npm, news sentiment, and 25+ live feeds. Powered by trendsmcp.ai.",
        "version": "0.1",
        "x-build-id": "tHep6sIElSkvEYUrd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trendsmcp~trendsmcp-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trendsmcp-trendsmcp-mcp",
                "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/trendsmcp~trendsmcp-mcp/runs": {
            "post": {
                "operationId": "runs-sync-trendsmcp-trendsmcp-mcp",
                "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/trendsmcp~trendsmcp-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-trendsmcp-trendsmcp-mcp",
                "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": {
                    "trendsApiKey": {
                        "title": "Trends MCP API Key",
                        "type": "string",
                        "description": "Your API key from trendsmcp.ai. Get one free at https://trendsmcp.ai"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
