Skip to main content
Glama

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 npx usage) and Streamable HTTP transport

  • Analytics 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

  1. Clone the repository:

git clone https://github.com/dailybeast/parsely-mcp.git
cd parsely-mcp
  1. Install dependencies:

npm install
  1. Create a .env file from the example:

cp .env.example .env
  1. Edit .env and add your Parse.ly credentials:

PARSELY_API_KEY=your_api_key_here
PARSELY_API_SECRET=your_api_secret_here
PORT=8742
  1. Build the project:

npm run build
  1. Run the server:

# Stdio transport (default)
npm start

# HTTP transport
node dist/index.js --http

When 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

  1. Build the Docker image:

docker build -t parsely-mcp .
  1. Run the container with environment variables:

docker run -e PARSELY_API_KEY=your_key -e PARSELY_API_SECRET=your_secret -p 8742:8742 parsely-mcp

Available 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 report

Running Tests

Tests use mocked Parse.ly API responses and don't require real credentials:

npm test

For tests that need environment variables:

PARSELY_API_KEY=test PARSELY_API_SECRET=test npm test

Configuration

All configuration is done via environment variables:

Variable

Required

Default

Description

PARSELY_API_KEY

Yes

-

Your Parse.ly API key

PARSELY_API_SECRET

Yes

-

Your Parse.ly API secret

PARSELY_API_BASE_URL

No

https://api.parse.ly/v2

Parse.ly API base URL

PORT

No

8742

Server port (HTTP mode only)

API Documentation

For more information about the Parse.ly API:

Contributing

Contributions are welcome! Please ensure:

  1. All tests pass (npm test)

  2. Code is linted (npm run lint)

  3. TypeScript compiles without errors (npm run build)

License

MIT License - see LICENSE for details

Support

For issues and questions:

Acknowledgments

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 tools
get_analytics_authorsA

Get analytics data for top authors from Parse.ly. Returns metrics like views and visitors by author.

ParametersJSON Schema
NameRequiredDescriptionDefault
daysNoNumber of days to look back (default: 7)
limitNoNumber of results to return (default: 10)

TDQS

A3.5/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
tagNoFilter by content tag
daysNoNumber of days to look back (default: 7, ignored if period_start set)
sortNoSort field (e.g., "hits", "avg_engaged_time")
limitNoNumber of results to return (default: 10)
sectionNoFilter by content section
period_endNoEnd date for traffic window (YYYY-MM-DD)
period_startNoStart date for traffic window (YYYY-MM-DD)
pub_date_endNoFilter by content published before this date
pub_date_startNoFilter by content published after this date

TDQS

B3.4/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness2/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines2/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
daysNoNumber of days to look back (default: 7)
limitNoNumber of results to return (default: 10)

TDQS

A3.8/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
daysNoNumber of days to look back (default: 7). Ignored if period_start/period_end provided.
typeNoReferrer type: "social", "search", "other", or "internal" (default: "social")social
limitNoNumber of results to return (default: 10)
domainNoFilter by specific domain
sectionNoFilter by content section
period_endNoEnd date for traffic window (YYYY-MM-DD or YYYY-MM-DDThh:mm). Use same as period_start for single day.
period_startNoStart date for traffic window (YYYY-MM-DD or YYYY-MM-DDThh:mm). Use for specific date queries.
pub_date_endNoFilter by content published before this date (YYYY-MM-DD)
pub_date_startNoFilter by content published after this date (YYYY-MM-DD)

TDQS

A3.7/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

get_sharesA

Get social share data for posts from Parse.ly. Shows total shares and breakdown by platform.

ParametersJSON Schema
NameRequiredDescriptionDefault
daysNoNumber of days to look back (default: 7)
limitNoNumber of results to return (default: 10)

TDQS

A3.8/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the burden of behavioral disclosure. It clearly indicates this is a read-only operation and specifies the output includes total shares and platform breakdown, but it does not mention potential behavior such as response format, pagination, sorting, or rate limits. This is adequate but not richly transparent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two short sentences, front-loaded with the primary action and resource, and includes a useful output summary. Every word earns its place; there is no redundant detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple tool with two optional, well-documented parameters and no output schema, the description sufficiently conveys what the tool does and what the response contains (total shares and platform breakdown). It lacks an explicit return type, but the overall context is complete enough for an AI agent to invoke it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema already covers both parameters (days and limit) with descriptions and defaults, so schema coverage is 100%. The description adds no extra parameter-level meaning, but given full schema coverage, a baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Get') and identifies a distinct resource ('social share data for posts from Parse.ly'), and further clarifies it shows total shares and breakdown by platform. This clearly differentiates it from sibling tools like get_referrers or get_analytics_posts, which focus on other analytics dimensions.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied: use it when you need social share counts for posts. However, there is no explicit guidance on when to choose this tool over siblings such as get_analytics_posts or get_referrers, nor any exclusions or alternative recommendations.

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
tagNoFilter by tag
pageNoPage number for pagination (default: 1)
sortNoSort order: 'score' (default) or 'pub_date'
boostNoSub-sort metric when sort=score (e.g., 'views')
limitNoNumber of results to return (default: 10)
queryYesSearch query string
authorNoFilter by author name
excludeNoExclude by metadata in format '<meta>:<value>'
sectionNoFilter by content section
pub_date_endNoFilter by publication date end (YYYY-MM-DD, defaults to now)
pub_date_startNoFilter by publication date start (YYYY-MM-DD)

TDQS

B3.4/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness2/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

  1. 6 tool updatesv0.1.3
    • First observedget_analytics_authors
    • First observedget_analytics_posts
    • First observedget_analytics_tags
    • First observedget_referrers
    • First observedget_shares
    • First observedsearch_content

TDQS

A3.9/5.0
Disambiguation5/5

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.

Naming Consistency5/5

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.

Tool Count5/5

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.

Completeness4/5

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

ActivityInactive
ResponsivenessSyncing

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

Related MCP Servers

  • A
    license
    Not graded
    quality
    C
    maintenance
    An 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,926
    MIT
  • A
    license
    Not graded
    quality
    D
    maintenance
    A 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
  • F
    license
    A
    quality
    D
    maintenance
    An 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
    -
  • F
    license
    Not graded
    quality
    D
    maintenance
    A 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

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