parsely-mcp
Provides tools for accessing Parse.ly analytics data, including top posts, authors, tags, referrers, content search, and social shares.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@parsely-mcpShow me top posts from the past week"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Parse.ly MCP Server
A Model Context Protocol (MCP) server that provides access to Parse.ly analytics API. This server enables AI assistants like Claude to query Parse.ly data for content analytics, referrers, search, and social shares.
Built with Claude Code - See CLAUDE.md for development guidance.
Features
Dual Transport: Supports both stdio (for
npxusage) and Streamable HTTP transportAnalytics Tools: Get metrics for top posts, authors, and tags with date-based queries
Referrer Data: Track traffic sources by type (social, search, other, internal)
Content Search: Search through Parse.ly content
Social Shares: View share counts across platforms
Date Range Support: Query specific days or ranges for time-based comparisons
Type-Safe: Built with TypeScript for reliability
Well-Tested: Comprehensive unit tests with mocked API responses
Docker Support: Easy containerized deployment with port exposure
Related MCP server: Google MCP Server
Prerequisites
Node.js >= 20.0.0
Parse.ly API credentials (API key and secret)
Get your credentials from https://dash.parse.ly/
Installation
Quick Start with npx
The easiest way to use this server is via npx. Add it to your MCP client configuration:
{
"mcpServers": {
"parsely": {
"command": "npx",
"args": ["parsely-mcp"],
"env": {
"PARSELY_API_KEY": "your_api_key_here",
"PARSELY_API_SECRET": "your_api_secret_here"
}
}
}
}This uses stdio transport, which is the default and works with Claude Desktop, Claude Code, and other MCP clients.
Local Development
Clone the repository:
git clone https://github.com/dailybeast/parsely-mcp.git
cd parsely-mcpInstall dependencies:
npm installCreate a
.envfile from the example:
cp .env.example .envEdit
.envand add your Parse.ly credentials:
PARSELY_API_KEY=your_api_key_here
PARSELY_API_SECRET=your_api_secret_here
PORT=8742Build the project:
npm run buildRun the server:
# Stdio transport (default)
npm start
# HTTP transport
node dist/index.js --httpWhen using --http, the server starts on http://localhost:8742 with:
MCP endpoint:
http://localhost:8742/mcp- Streamable HTTP transport (POST, GET, DELETE)Health check:
http://localhost:8742/health- Server health status
Docker
Build the Docker image:
docker build -t parsely-mcp .Run the container with environment variables:
docker run -e PARSELY_API_KEY=your_key -e PARSELY_API_SECRET=your_secret -p 8742:8742 parsely-mcpAvailable Tools
The MCP server exposes the following tools:
get_analytics_posts
Get analytics data for top posts.
Parameters:
days(number, default: 7),limit(number, default: 10),sort(string, optional)
get_analytics_authors
Get analytics data for top authors.
Parameters:
days(number, default: 7),limit(number, default: 10)
get_analytics_tags
Get analytics data for top tags.
Parameters:
days(number, default: 7),limit(number, default: 10)
get_referrers
Get referrer data showing traffic sources.
Parameters:
days(number, default: 7),limit(number, default: 10),type(string, optional: "social", "search", etc.)
search_content
Search Parse.ly content.
Parameters:
query(string, required),limit(number, default: 10)
get_shares
Get social share data for posts.
Parameters:
days(number, default: 7),limit(number, default: 10)
Development
Available Scripts
npm run build # Compile TypeScript
npm run dev # Watch mode for development
npm run lint # Run ESLint
npm test # Run tests
npm run test:watch # Run tests in watch mode
npm run test:coverage # Generate coverage reportRunning Tests
Tests use mocked Parse.ly API responses and don't require real credentials:
npm testFor tests that need environment variables:
PARSELY_API_KEY=test PARSELY_API_SECRET=test npm testConfiguration
All configuration is done via environment variables:
Variable | Required | Default | Description |
| Yes | - | Your Parse.ly API key |
| Yes | - | Your Parse.ly API secret |
| No |
| Parse.ly API base URL |
| No |
| Server port (HTTP mode only) |
API Documentation
For more information about the Parse.ly API:
Contributing
Contributions are welcome! Please ensure:
All tests pass (
npm test)Code is linted (
npm run lint)TypeScript compiles without errors (
npm run build)
License
MIT License - see LICENSE for details
Support
For issues and questions:
GitHub Issues: https://github.com/dailybeast/parsely-mcp/issues
Parse.ly Documentation: https://docs.parse.ly/
Acknowledgments
Built with Claude Code - AI-assisted development
Model Context Protocol SDK - TypeScript SDK for MCP
Parse.ly API - Content analytics platform
Development
This project uses CLAUDE.md for AI-assisted development guidance. The file contains:
Architecture overview and code organization
Common development commands
Testing requirements and conventions
Open-source best practices
Available Tools
6 toolsget_analytics_authorsA
Get analytics data for top authors from Parse.ly. Returns metrics like views and visitors by author.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | Number of days to look back (default: 7) | |
| limit | No | Number of results to return (default: 10) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must disclose behavioral traits on its own. It mentions the returned metrics but does not state that the operation is read-only, that results are sorted by 'top', or how the days and limit parameters affect behavior, which is a gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that gets directly to the point without unnecessary filler. It is appropriately sized for the tool's simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The absence of an output schema places more responsibility on the description to explain returns; while it gives examples ('views and visitors'), it lacks specificity about ordering, default limit, or the exact output structure. It also does not reference sibling tools, so context is only partially complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already fully documents both parameters (days and limit) with descriptions and defaults, so the description adds no extra parameter-level meaning. The baseline of 3 applies because schema coverage is 100%.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Get analytics data') applied to a defined resource ('top authors from Parse.ly'), and includes result details ('metrics like views and visitors by author'). This clearly distinguishes it from sibling tools focused on posts or tags.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use for author-level analytics but does not explicitly state when to use it versus sibling tools like get_analytics_posts or get_analytics_tags. No exclusions or alternatives are mentioned, leaving usage guidance implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_analytics_postsB
Get analytics data for top posts from Parse.ly. Returns metrics like views, visitors, and engagement time. Supports specific date ranges.
| Name | Required | Description | Default |
|---|---|---|---|
| tag | No | Filter by content tag | |
| days | No | Number of days to look back (default: 7, ignored if period_start set) | |
| sort | No | Sort field (e.g., "hits", "avg_engaged_time") | |
| limit | No | Number of results to return (default: 10) | |
| section | No | Filter by content section | |
| period_end | No | End date for traffic window (YYYY-MM-DD) | |
| period_start | No | Start date for traffic window (YYYY-MM-DD) | |
| pub_date_end | No | Filter by content published before this date | |
| pub_date_start | No | Filter by content published after this date |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It mentions that the tool returns metrics and supports date ranges, but does not add deeper context such as pagination, sorting behavior, or how 'top' is determined. This is minimal but not misleading.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences, front-loaded with the core action and resource. Every word earns its place with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite 9 parameters and no output schema, the description is very brief. It does not explain what 'top' means, how parameters interact (e.g., days vs period_start), or what the response structure looks like. The schema covers parameter details, but the overall tool context is insufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific detail beyond what the schema already provides; it only mentions generic support for date ranges, which is already covered by period_start/period_end/days fields.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves analytics data for top posts from Parse.ly, using a specific verb ('Get') and resource ('analytics data for top posts'). This distinguishes it from sibling tools like get_analytics_authors or get_analytics_tags.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. The description implies it is for post-level analytics, but does not mention when it should be preferred over author/tag analytics or search_content. No exclusions or alternative tool mentions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_analytics_tagsA
Get analytics data for top tags from Parse.ly. Returns metrics like views and visitors by tag.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | Number of days to look back (default: 7) | |
| limit | No | Number of results to return (default: 10) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the return value (metrics like views and visitors by tag) but does not mention sorting criteria for 'top', pagination behavior, or other operational details. Acceptable for a simple read operation but limited.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences, front-loaded with a clear action verb, and contains no fluff or repetition. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 2-parameter read-only tool, the description adequately states the purpose and return type. It could clarify what 'top' means (e.g., sorted by views) but overall provides sufficient context given the schema covers parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for both parameters (days and limit), so the baseline is 3. The description adds no additional semantics beyond the schema's field descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool gets analytics data for top tags from Parse.ly, with a specific verb ('Get') and resource ('top tags'). This distinguishes it from sibling tools like get_analytics_posts and get_analytics_authors by focusing specifically on tags.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for tag-level analytics but does not explicitly state when to use this tool vs. the sibling analytics tools, nor does it provide exclusions or alternatives. Sibling names suggest alternatives, but no direct guidance is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_referrersA
Get referrer data from Parse.ly. Shows where traffic is coming from by type: social, search, other, or internal. Supports specific date ranges for comparison analysis.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | Number of days to look back (default: 7). Ignored if period_start/period_end provided. | |
| type | No | Referrer type: "social", "search", "other", or "internal" (default: "social") | social |
| limit | No | Number of results to return (default: 10) | |
| domain | No | Filter by specific domain | |
| section | No | Filter by content section | |
| period_end | No | End date for traffic window (YYYY-MM-DD or YYYY-MM-DDThh:mm). Use same as period_start for single day. | |
| period_start | No | Start date for traffic window (YYYY-MM-DD or YYYY-MM-DDThh:mm). Use for specific date queries. | |
| pub_date_end | No | Filter by content published before this date (YYYY-MM-DD) | |
| pub_date_start | No | Filter by content published after this date (YYYY-MM-DD) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden for behavioral disclosure. It discloses the core read operation and the ability to filter by referrer type and date range, but it does not describe the return format, pagination behavior, or any limitations. It is not contradictory but lacks depth.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with the primary action and resource front-loaded. Every word contributes: it names the tool, the data source, the referrer types, and a key capability. No redundant or filler wording.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 9 parameters and no output schema, the description provides a high-level result ('Shows where traffic is coming from') and a key feature (date ranges), but it does not explain the return structure or mention filtering options like domain or section. It is adequate but not comprehensive for a tool of this complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds a hint about date ranges being useful for comparison analysis, but it does not add meaning beyond what the schema already provides for any of the 9 parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it fetches referrer data and specifies the types ('social', 'search', 'other', 'internal'), which distinguishes it from sibling analytics tools focused on posts, authors, tags, shares, or content search. The verb 'get' and resource 'referrer data' are specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description offers a use case ('Supports specific date ranges for comparison analysis') but does not explicitly mention alternatives or when not to use this tool. The context is implied rather than explicit, and there is no comparison with sibling tools like get_analytics_posts or get_shares.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_contentB
Search Parse.ly content. Find articles, posts, and pages by keyword.
| Name | Required | Description | Default |
|---|---|---|---|
| tag | No | Filter by tag | |
| page | No | Page number for pagination (default: 1) | |
| sort | No | Sort order: 'score' (default) or 'pub_date' | |
| boost | No | Sub-sort metric when sort=score (e.g., 'views') | |
| limit | No | Number of results to return (default: 10) | |
| query | Yes | Search query string | |
| author | No | Filter by author name | |
| exclude | No | Exclude by metadata in format '<meta>:<value>' | |
| section | No | Filter by content section | |
| pub_date_end | No | Filter by publication date end (YYYY-MM-DD, defaults to now) | |
| pub_date_start | No | Filter by publication date start (YYYY-MM-DD) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the basic search function and omits details about pagination, sorting, return format, or any side effects. This is minimal value beyond the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences with zero wasted words. It front-loads the core action and resource, making it easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite a comprehensive schema with 11 parameters, the description gives no context about what the response contains, how pagination works, or how to structure complex queries. With no annotations or output schema, the description is too sparse for a tool of this complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers 100% of parameters with descriptions, so the baseline is 3. The description's phrase 'by keyword' aligns with the query parameter but adds no new meaning to the other parameters, which are already well-documented in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action ('Search') and resource ('Parse.ly content'), specifying content types (articles, posts, pages). It distinguishes itself from sibling analytics tools by focusing on content retrieval rather than analytics metrics.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for finding content by keyword, which differentiates it from sibling analytics tools, but it does not explicitly state when to use this tool versus alternatives or provide exclusions (e.g., for analytics use get_analytics_posts).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
6 tool updates
v0.1.3- First observed
get_analytics_authors - First observed
get_analytics_posts - First observed
get_analytics_tags - First observed
get_referrers - First observed
get_shares - First observed
search_content
TDQS
Each tool clearly targets a distinct facet of Parse.ly data: top posts, top authors, top tags, referrers, content search, and social shares. There is no overlap or ambiguity in purpose.
All tool names follow a predictable snake_case pattern with a verb (get or search) and a noun. The analytics tools share a get_analytics_ prefix, while others are get_referrers, get_shares, and search_content, which is still consistent and intuitive.
With 6 tools, the set is well-scoped for a Parse.ly analytics server. Each tool serves a distinct data retrieval need without unnecessary bloat or thin coverage.
The set covers the primary analytics dimensions (posts, authors, tags), referrers, shares, and content search. Missing are time-series breakdowns or advanced filtering, but the core read-only analytics surface is largely complete.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
MCP server that lets AI assistants use all OneSchema features exposed via the public API.
MCP server for querying and analyzing data from ad platforms, analytics tools, and spreadsheets
MCP server for building and testing AI agents with multi-model experimentation and insights.
- ZapierOAuthcom.zapier
Hosted MCP server connecting AI assistants to 9,000+ apps and 40,000+ actions via Zapier.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceAn MCP server that connects AI assistants to SEO platforms like Google Search Console, GA4, Bing Webmaster Tools, and Adobe Analytics, enabling natural language queries about SEO performance.2,926MIT
- AlicenseNot gradedqualityDmaintenanceA unified MCP server that gives AI assistants direct access to Google Analytics 4, Google Search Console, Google Ads and Google Merchant Center data using OAuth2 user credentials.MIT
- FlicenseAqualityDmaintenanceAn MCP server that provides Google Analytics and Search Console data as tools for AI assistants, enabling natural language queries for web analytics, SEO performance, and site insights.13-
- FlicenseNot gradedqualityDmaintenanceA comprehensive MCP server that provides AI assistants with powerful access to Pendo analytics through 15 specialized tools, transforming natural language questions into deep product insights.-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/dailybeast/parsely-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server