Parallel-Poke MCP

A bridge between Parallel's Monitor API and Poke - get SMS notifications when your web monitors detect changes, and manage monitors conversationally through Poke.

What It Does

Receives webhooks from Parallel when your monitors detect web changes
Forwards event details to Poke which sends you an SMS notification
Exposes MCP tools so Poke can create/manage monitors on your behalf

This means you can text Poke things like:

"Create a monitor for React changelog updates, check daily"
"What monitors do I have?"
"Show me recent events"
"Delete the OpenAI monitor"

And you'll automatically get SMS notifications when any monitor detects changes.

Deploy

Option 1: Render (Recommended)

Option 2: Railway

Option 3: Manual Deployment

Fork this repository
Deploy to any platform that supports Python (Render, Railway, Fly.io, etc.)
Set the environment variables (see below)
Your server will be available at https://your-app-url.com/mcp

Configuration

Set these environment variables in your deployment platform:

Variable	Required	Description
`PARALLEL_API_KEY`	Yes	Your Parallel API key from platform.parallel.ai
`POKE_API_KEY`	Yes	Your Poke API key from poke.com/settings/advanced
`WEBHOOK_BASE_URL`	Yes	Your deployed server URL (e.g., `https://your-app.onrender.com`)
`PARALLEL_WEBHOOK_SECRET`	No	Webhook signing secret for verification (recommended)
`MCP_AUTH_TOKEN`	No	If set, MCP clients must send `Authorization: Bearer <token>`
`NOTIFY_COMPLETION_EVENTS`	No	If true, send completion (no-change) notifications (default false)

Connect to Poke

Deploy the server and note your URL (e.g., https://parallel-poke-mcp.onrender.com)
Go to poke.com/settings/connections
Add a new MCP integration with URL: https://your-url.com/mcp
Test by texting Poke: "List my Parallel monitors"

Endpoints

Endpoint	Purpose
`/mcp`	MCP protocol endpoint (Poke connects here)
`/webhook/parallel`	Receives webhooks from Parallel monitors
`/health`	Health check for load balancers

MCP Auth (Optional)

If you set MCP_AUTH_TOKEN, the MCP endpoint requires a bearer token:

Authorization: Bearer <your token>

If your MCP client supports auth (e.g., Poke), configure the same token there.

MCP Tools

The server exposes these tools to Poke:

Tool	Description
`create_monitor`	Create a new monitor with a query and cadence (hourly/daily/weekly)
`list_monitors`	List all your active monitors
`get_monitor`	Get details of a specific monitor
`update_monitor`	Update a monitor (cadence, webhook, metadata)
`delete_monitor`	Delete a monitor
`list_recent_events`	Get recent events across monitors

Webhook event types supported by the API:

monitor.event.detected
monitor.execution.completed
monitor.execution.failed

Use update_monitor to set webhook_event_types if you want completion/failure notifications.

By default, completion events are ignored. Set NOTIFY_COMPLETION_EVENTS=true to send them. Metadata values must be strings (Parallel API requirement).

Local Development

# Clone the repo
git clone https://github.com/YOUR_USERNAME/parallel-poke-mcp.git
cd parallel-poke-mcp

# Create virtual environment
python3 -m venv venv
source venv/bin/activate  # or `venv\Scripts\activate` on Windows

# Install dependencies
python3 -m pip install -r requirements.txt

# Set environment variables
cp .env.example .env
# Edit .env with your API keys

# Run the server
python3 src/server.py

Test with the MCP Inspector:

npx @modelcontextprotocol/inspector

Connect to http://localhost:8000/mcp using "Streamable HTTP" transport.

How It Works

┌─────────────────────┐
│  Parallel Monitors  │  You define what to watch
│  (hourly/daily/wk)  │  "React changelog updates"
└─────────┬───────────┘
          │ webhook fires when changes detected
          ▼
┌─────────────────────┐
│  This MCP Server    │  Receives webhook, fetches
│  (Render/Railway)   │  full event details
└─────────┬───────────┘
          │ forwards to Poke API
          ▼
┌─────────────────────┐
│       Poke          │  AI formats and sends
└─────────┬───────────┘  SMS notification
          │
          ▼
        [SMS]

Plus, Poke can call the MCP tools to manage monitors:

You: "Create a monitor for Vercel changelog, check weekly"
          │
          ▼
┌─────────────────────┐
│       Poke          │  Calls create_monitor tool
└─────────┬───────────┘
          │ MCP tool call
          ▼
┌─────────────────────┐
│  This MCP Server    │  Calls Parallel API
└─────────┬───────────┘  to create monitor
          │
          ▼
┌─────────────────────┐
│  Parallel API       │  Monitor created!
└─────────────────────┘

Example Use Cases

Changelog monitoring: Track updates to tools you use (React, Next.js, etc.)
News alerts: Monitor announcements from companies you follow
Price tracking: Watch for deals on products
Competitor monitoring: Track competitor announcements or launches
Job postings: Monitor career pages at companies you're interested in

Troubleshooting

Poke isn't calling my MCP tools

Make sure the MCP URL ends with /mcp (e.g., https://your-app.onrender.com/mcp)
Try sending clearhistory to Poke to reset conversation state
Ask Poke explicitly: "Use the Parallel Monitor integration to list monitors"

Webhooks aren't working

Check that WEBHOOK_BASE_URL is set correctly (no trailing slash)
Verify your Parallel webhook secret matches if you're using signature verification
Check the /health endpoint to confirm the server is running

Monitor creation fails

Ensure PARALLEL_API_KEY is set correctly
Check that WEBHOOK_BASE_URL is accessible from the internet

License

MIT

parallel-poke-mcp