ParseStream

ParseStream MCP Server

ParseStream watches Reddit, X, LinkedIn, Quora and Hacker News for mentions of your brand, scores each one for relevance and buying intent, and writes reply drafts. This server hands that to your AI assistant: ask what people said about you this week, which of those sound like someone shopping for a tool, pull one up in full, and get a draft back that you edit and send yourself.

Nothing here can post. There is no tool on this server that publishes to Reddit, X, LinkedIn, Quora or Hacker News, or that contacts anyone.

It is a remote server — nothing to install or run locally, just a URL and an API key.

Get an API key first

In ParseStream, go to Brand Settings → API Keys and create one. It starts with ps_live_ and is shown exactly once, so copy it straight into your client config.

A key is scoped to a single brand — the server never reads arguments to decide whose data you get, only the key. To connect a second brand, mint a second key and add it as a second MCP server under a different name. Revoking a key in Brand Settings cuts off MCP access immediately.

It is the same key the Mentions REST API uses, and both share one budget: 100 requests per minute per key. Every JSON-RPC call counts, including the tools/list your client fetches on connect. Over the limit you get a 429 with a Retry-After header.

Install

Replace ps_live_xxxxxxxxxxxxxxxx with your own key in whichever block matches your tool, then restart the client. Every one of these clients can read the key from an environment variable instead of holding it in the file — see Connecting without exposing your key, and read it first if any of these files lives inside a repository.

Claude Code

claude mcp add --transport http parsestream https://mcp.parsestream.com/mcp \

--header "Authorization: Bearer ps_live_xxxxxxxxxxxxxxxx" \ -s local

[!WARNING]

Keep -s local. The -s project scope writes your key in plaintext into .mcp.json

at the repo root — a file meant to be committed and shared with your team. A live

ParseStream key ends up in git history, and if the repo is public, in the hands of

anyone who clones it. -s local (the default) stores it in your own user config

outside the repository, scoped to this project; -s user does the same but makes the

server available in every project. Neither puts anything in the working tree. If your

team genuinely needs a shared .mcp.json, put the *variable* in it rather than the

key — below.

Verify with claude mcp list, or just ask the assistant *"what ParseStream brand am I connected to?"* — it should name your brand and list your tracked keywords.

Claude Code can also install this repo as a plugin, which sets the server up for you and reads the key from an environment variable instead of a config file:

/plugin marketplace add parsestream/parsestream-mcp

/plugin install parsestream@parsestream

Then export PARSESTREAM_API_KEY=ps_live_... in your shell profile.

Cursor

~/.cursor/mcp.json (or .cursor/mcp.json inside a project — same caveat as above, do not commit it):

{

"mcpServers": { "parsestream": { "url": "https://mcp.parsestream.com/mcp", "headers": { "Authorization": "Bearer ps_live_xxxxxxxxxxxxxxxx" } } } }

The Add to Cursor badge at the top writes this file for you, with the placeholder key in it — open the entry in Cursor's MCP settings afterwards and paste your real one.

VS Code (GitHub Copilot)

.vscode/mcp.json — note the top-level key is servers, not mcpServers. VS Code is the odd one out here:

{

"servers": { "parsestream": { "type": "http", "url": "https://mcp.parsestream.com/mcp", "headers": { "Authorization": "Bearer ps_live_xxxxxxxxxxxxxxxx" } } } }

.vscode/mcp.json is usually committed, so prefer VS Code's inputs mechanism, or your user-level mcp.json (MCP: Open User Configuration in the command palette), rather than pasting a live key into a tracked file.

Codex CLI

~/.codex/config.toml. Codex can read the key from the environment, which keeps it out of the config file entirely:

[mcp_servers.parsestream]

url = "https://mcp.parsestream.com/mcp" bearer_token_env_var = "PARSESTREAM_API_KEY"

Then export PARSESTREAM_API_KEY="ps_live_xxxxxxxxxxxxxxxx" in your shell profile. If you would rather inline it, use http_headers — note that the key is http_headers, not headers:

[mcp_servers.parsestream]

url = "https://mcp.parsestream.com/mcp" http_headers = { Authorization = "Bearer ps_live_xxxxxxxxxxxxxxxx" }

Grok

There is no Grok connector directory to be listed in, but Grok accepts a bring-your-own MCP server: at grok.com/connectors, add a custom connector with the URL https://mcp.parsestream.com/mcp and an Authorization header of Bearer ps_live_....

Grok's terminal agent reads Claude Code's MCP configuration, so if you already ran the claude mcp add command above, it is already connected there.

Claude Desktop and claude.ai

Not yet. A listing in Anthropic's connector directory is planned but not available at the time of writing, so there is no one-click install in the Claude apps. Claude Code works today and is the fastest way to try this.

Connecting without exposing your key

One rule: the key belongs in your environment or in a file under your home directory, never in a file you commit. ~/.claude.json, ~/.cursor/mcp.json and ~/.codex/config.toml are outside every repository and holding a key there is fine. .mcp.json, .cursor/mcp.json and .vscode/mcp.json are the project-scoped versions of those files, and all three exist to be shared with a team — Claude Code's and VS Code's docs tell you to commit them outright. That is where keys leak.

Every client below can read the key out of the environment instead. The syntax differs per client, which is the entire reason this section is four snippets rather than one. Export it once:

export PARSESTREAM_API_KEY="ps_live_xxxxxxxxxxxxxxxx"

Codex CLI

Codex is the only one of the four that stores the *name* of the variable rather than a value, so nothing key-shaped ever reaches the file:

[mcp_servers.parsestream]

url = "https://mcp.parsestream.com/mcp" bearer_token_env_var = "PARSESTREAM_API_KEY"

Or, without editing the file:

codex mcp add parsestream --url https://mcp.parsestream.com/mcp \

--bearer-token-env-var PARSESTREAM_API_KEY

The config file carries a variable name and a URL and is safe to commit as it stands. This is the design to want; the other three are workarounds by comparison.

Claude Code

-s local (the default) and -s user both write to ~/.claude.json, in your home directory. Nothing lands in the working tree and there is nothing further to do — the claude mcp add command in the Install section above is already safe.

Reach for a variable when the entry has to be project-scoped and shared. Claude Code expands ${VAR} and ${VAR:-default} inside command, args, env, url and headers, so a committed .mcp.json can carry the reference:

{

"mcpServers": { "parsestream": { "type": "http", "url": "https://mcp.parsestream.com/mcp", "headers": { "Authorization": "Bearer ${PARSESTREAM_API_KEY}" } } } }

This is exactly what the plugin ships, which is why the plugin needs no config file of your own.

[!IMPORTANT]

If the variable is unset, Claude Code does not fail — it sends the literal text.

The server recognises that and says so, naming the variable in the 401

error_description:

`

Unexpanded variable, not a bad key: your MCP client sent the reference

${PARSESTREAM_API_KEY} instead of the value it stands for, which means

PARSESTREAM_API_KEY is not set in the environment the client runs in. Export

PARSESTREAM_API_KEY=ps_live_... in your shell profile, then fully restart the client

so it inherits the value.

`

An export that only runs for interactive shells, or a client launched from the desktop

rather than a terminal, produces exactly this.

${input:...} prompts are a VS Code feature; Claude Code does not support them, and a config using one will send that literal too.

Cursor

Same idea, different spelling: Cursor wants ${env:NAME}, not ${NAME}. The files look alike but are not interchangeable, and pasting a Claude Code config here sends the placeholder verbatim.

{

"mcpServers": { "parsestream": { "url": "https://mcp.parsestream.com/mcp", "headers": { "Authorization": "Bearer ${env:PARSESTREAM_API_KEY}" } } } }

Cursor expands it in command, args, env, url and headers. Keep this in ~/.cursor/mcp.json if the setup is just yours; the ${env:...} form is what makes a project-level .cursor/mcp.json safe to commit.

VS Code (GitHub Copilot)

.vscode/mcp.json is meant to be committed, so a literal key there is the same mistake as -s project. Use ${env:VAR}, or point envFile at a gitignored .env:

{

"servers": { "parsestream": { "type": "http", "url": "https://mcp.parsestream.com/mcp", "headers": { "Authorization": "Bearer ${env:PARSESTREAM_API_KEY}" } } } }

VS Code also has an inputs mechanism that prompts once and remembers the answer — {"type": "promptString", "id": "parsestream-key", "password": true} at the top level, referenced as ${input:parsestream-key}. The documented examples put it in an env block; there is no documented example of ${input:} inside an HTTP headers block, so treat that combination as untested and prefer ${env:...} or envFile for this server. VS Code describes what it keeps only as "securely stored" — it does not promise the OS keychain.

Secret managers

Both of these compose with the configs above: they populate the environment, the client reads it, and no file changes.

• 1Password CLI — hold PARSESTREAM_API_KEY as an op:// reference and launch the client through it: op run -- claude. The secret exists only for that process. Resolving op:// from inside Claude Code's own config is an open request, not something that works today.
• direnv — a gitignored .envrc containing export PARSESTREAM_API_KEY=ps_live_..., then direnv allow. The key is in the environment while you are in that directory and nowhere else.

If you already committed a key

Revoke it. **Brand Settings → API Key