Miinta Pipedrive MCP
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., "@Miinta Pipedrive MCPShow my sales digest for overdue and today's follow-ups"
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.
Miinta Pipedrive MCP v0.1
Read-only MCP (Model Context Protocol) server for Pipedrive that provides a digest-ready sales queue with:
Overdue follow-up activities (from a Pipedrive filter)
Due today follow-up activities (from a Pipedrive filter)
Deals missing next action (from a Pipedrive filter)
Features
Single Tool:
miinta.sales_queue.get- Returns a comprehensive sales digestPipedrive API v2: Uses modern Pipedrive API for activities, deals, persons, organizations, and stages
Data Enrichment:
Stage names for deals
Contact information (email) for persons
Direct deal URLs with configurable company domain
Days overdue calculation for activities
Deal metadata (undone activities count, last mail times)
Smart Features:
Cursor-based pagination support
Bulk fetching for persons/organizations (avoids N+1 queries)
Caching for improved performance (configurable TTL)
Configurable timezone support (default: Europe/Madrid)
Standard MCP stdio transport for streaming communication
Bearer authentication for Pipedrive API
Flexible: Filter IDs provided per request (not hardcoded in environment)
Related MCP server: pipedrive-pj
Quick Start
git clone https://github.com/alvarolloret/pipedrive-mcp.git && cd pipedrive-mcpmake allAdd MCP with one command (pick one):
claude mcp add pipedrive -- docker run -i --rm --env-file /Users/alvarodemuller/miinta/pipedrive-mcp/.env pipedrive-mcporcodex mcp add pipedrive -- docker run -i --rm --env-file /Users/alvarodemuller/miinta/pipedrive-mcp/.env pipedrive-mcp
Configuration
Pipedrive API Token
Get your API token from Pipedrive:
Go to your Pipedrive account settings
Navigate to Personal preferences → API
Copy your API token
Create a .env file based on .env.example:
# Required: Pipedrive API Token (Bearer token)
PIPEDRIVE_API_TOKEN=your_pipedrive_api_token_here
# Optional: Pipedrive API Base URL (default: https://api.pipedrive.com/v2)
PIPEDRIVE_API_BASE=https://api.pipedrive.com/v2
# Optional: Pipedrive Company Domain for deal URLs (default: app.pipedrive.com)
# Example: yourcompany.pipedrive.com
PIPEDRIVE_COMPANY_DOMAIN=yourcompany.pipedrive.com
# Optional: MCP Authentication Token (required if not localhost)
MCP_AUTH_TOKEN=your_mcp_auth_token_here
# Optional: Default timezone (default: Europe/Madrid)
DEFAULT_TIMEZONE=Europe/Madrid
# Optional: Cache TTL in seconds (default: 3600)
CACHE_TTL_SECONDS=3600
# Optional: Maximum items per section (default: 50)
MAX_ITEMS_PER_SECTION=50
# Optional: Transport mode - stdio, http, or sse (default: stdio)
TRANSPORT_MODE=stdio
# Optional: HTTP Server Port (default: 3000, only used if TRANSPORT_MODE is http or sse)
HTTP_PORT=3000Required Pipedrive Filters
You need to create three saved filters in your Pipedrive account:
Overdue Activities Filter: Filter for activities with
done=falseanddue_date < todayToday's Activities Filter: Filter for activities with
done=falseanddue_date = todayDeals Missing Next Action Filter: Filter for open deals without a next activity scheduled
Get the filter IDs from the Pipedrive UI or API. These will be provided when calling the tool (not in environment variables).
MCP Tool
The server exposes one tool: miinta.sales_queue.get
Input Schema (JSON Schema):
{
"type": "object",
"additionalProperties": false,
"properties": {
"filters": {
"type": "object",
"additionalProperties": false,
"properties": {
"overdue_activities_filter_id": { "type": "integer" },
"today_activities_filter_id": { "type": "integer" },
"missing_next_action_deals_filter_id": { "type": "integer" }
},
"required": [
"overdue_activities_filter_id",
"today_activities_filter_id",
"missing_next_action_deals_filter_id"
]
},
"limits": {
"type": "object",
"additionalProperties": false,
"properties": {
"overdue": { "type": "integer", "minimum": 1, "maximum": 200, "default": 25 },
"today": { "type": "integer", "minimum": 1, "maximum": 200, "default": 25 },
"missing": { "type": "integer", "minimum": 1, "maximum": 200, "default": 25 }
}
},
"timezone": { "type": "string", "default": "Europe/Madrid" },
"now": {
"type": "string",
"description": "Optional ISO datetime override for deterministic testing"
},
"include_people_orgs": { "type": "boolean", "default": true }
},
"required": ["filters"]
}Example Request:
{
"filters": {
"overdue_activities_filter_id": 111,
"today_activities_filter_id": 222,
"missing_next_action_deals_filter_id": 333
},
"limits": {
"overdue": 25,
"today": 25,
"missing": 25
},
"timezone": "Europe/Madrid",
"include_people_orgs": true
}Example Response:
{
"generated_at": "2026-02-16T07:45:00+01:00",
"timezone": "Europe/Madrid",
"sections": {
"overdue": [
{
"activity_id": 123,
"activity_subject": "Follow-up email",
"activity_type": "email",
"due_date": "2026-02-14",
"days_overdue": 2,
"deal": {
"deal_id": 456,
"title": "Escola X — Pilot",
"stage_id": 3,
"stage_name": "Conversation open neutral",
"url": "https://yourcompany.pipedrive.com/deal/456"
},
"person": {
"id": 10,
"name": "Maria Rius",
"email": "maria@example.com"
},
"org": {
"id": 20,
"name": "Escola X"
}
}
],
"due_today": [],
"missing_next_action": [
{
"deal_id": 789,
"title": "Universitat Y — Training",
"stage_id": 2,
"stage_name": "Contact",
"owner_id": 1,
"undone_activities_count": 0,
"next_activity_id": null,
"last_outgoing_mail_time": "2026-02-10T09:12:00Z",
"last_incoming_mail_time": null,
"url": "https://yourcompany.pipedrive.com/deal/789",
"person": {
"id": 11,
"name": "Joan Garcia"
},
"org": {
"id": 21,
"name": "Universitat Y"
}
}
]
},
"stats": {
"overdue_count": 1,
"due_today_count": 0,
"missing_next_action_count": 1
},
"source": {
"filter_ids": {
"overdue_activities_filter_id": 111,
"today_activities_filter_id": 222,
"missing_next_action_deals_filter_id": 333
}
}
}Architecture
Pipedrive Client (
pipedrive-client.ts): Handles all Pipedrive API v2 interactionsActivities filtering with
done=false, sortingDeals filtering with
status=open,include_fieldsCursor-based pagination
Bulk fetching for persons/organizations
Cache (
cache.ts): In-memory caching with TTL supportSales Queue Service (
sales-queue.ts): Business logic for aggregating and enriching dataStage name resolution
Days overdue calculation
Person/org enrichment with bulk fetching
Deal URL generation with company domain
MCP Server (
index.ts): MCP protocol implementation with stdio transport
API Version
This server uses Pipedrive API v2 endpoints:
/v2/activities- withfilter_id,done=false,sort_by=due_date/v2/deals- withfilter_id,status=open,include_fields/v2/persons- with bulkidsparameter/v2/organizations- with bulkidsparameter/v2/stages- cached for stage name resolution
Error Handling
The server implements two layers of error handling as per MCP spec:
Protocol errors (JSON-RPC) for invalid args/unknown tool
Tool execution errors: returns
isError: truewith readable error messages for:Pipedrive auth failures
Rate limit / transient upstream errors
Invalid filter_id / permission issues
Missing required parameters
Development
# Build TypeScript only
make build
# Full rebuild (clean + Docker image)
make all
# Clean compiled output
make cleanAcceptance Criteria
The server is considered "production-ready" when it:
✅ Accepts three filter IDs via tool call parameters
✅ Returns correct items from each filter
✅ Calculates correct
days_overduein specified timezone✅ Resolves correct
stage_namevalues from cached stage map✅ Includes person/org names when available
✅ Generates valid deal links using
PIPEDRIVE_COMPANY_DOMAIN✅ Handles pagination via
cursoruntil requested limits are filled✅ Includes deal fields:
undone_activities_count,last_incoming_mail_time,last_outgoing_mail_time✅ Uses bulk fetching for persons/orgs to avoid N+1 queries
✅ Returns output in exact spec format with
sections,stats,source
License
ISC
Available Tools
4 toolsmiinta.filters.createA
Create a new Pipedrive saved filter. Useful for creating custom activity or deal filters that can then be used with miinta.sales_queue.get. Returns the created filter with its ID.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Name for the new filter | |
| type | Yes | The entity type this filter applies to. | |
| conditions | Yes | Pipedrive filter conditions JSON. Full format: {"glue":"and","conditions":[{"glue":"and","conditions":[...]},{"glue":"or","conditions":[...]}]}. Shorthand with only one "and" group is also accepted and auto-normalized. Each condition object has: object (e.g. "deal","activity","organization"), field_id, operator (e.g. "=","!=","IS NOT NULL"), value, extra_value. field_id can be numeric ID or field key/name; it is auto-resolved when possible. Max 16 conditions per filter. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the full behavioral burden. It discloses the return value (created filter with ID), but omits potential errors, idempotency, or permission requirements. This is minimal but not entirely absent.
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 no wasted words. It front-loads the action and then adds context and return behavior.
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 detailed schema covers the complex conditions object and type enum, while the description adds the sales_queue.get use case and return value. It lacks error handling info, but is otherwise sufficient for a create tool.
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 schema fully documents all three parameters. The description adds no extra parameter meaning beyond what the schema already provides.
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 creates a new Pipedrive saved filter with a specific verb and resource. It also distinguishes from siblings (list, delete) by noting its use with miinta.sales_queue.get.
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 gives a clear usage context: creating custom filters for later use with the sales queue. It doesn't explicitly exclude alternatives, but the create/list/delete relationship among siblings is implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
miinta.filters.deleteA
Delete a Pipedrive saved filter by its ID. Use miinta.filters.list to find filter IDs.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | The ID of the filter to delete |
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 states the action ('delete') but does not mention irreversibility, permissions, side effects, or return values, which are important for a delete operation.
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 long, front-loaded with the core action, and contains no extraneous information. It uses the available space efficiently.
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 single-parameter delete operation, the description provides the essential context: what to delete, how to specify it, and how to find valid IDs. It stops short of noting destructive implications, but the tool's simplicity reduces the need for more.
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 parameter is already well-documented. The description adds context by telling the user to use miinta.filters.list to find filter IDs, which is helpful but does not introduce new semantic detail about the 'id' parameter itself.
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 verb ('Delete') and resource ('Pipedrive saved filter') with a clear scope (by ID). It also distinguishes itself from sibling tools like miinta.filters.list and miinta.filters.create.
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 clearly implies when to use this tool (when you have a filter ID to delete) and provides a direct pointer to miinta.filters.list for finding IDs. It lacks explicit exclusion of alternative tools, but the distinction from siblings is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
miinta.filters.listA
List all available Pipedrive saved filters. Useful for discovering filter IDs and names before calling miinta.sales_queue.get. Optionally filter by type.
| Name | Required | Description | Default |
|---|---|---|---|
| type | No | Optional filter type to narrow results. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of behavioral disclosure. 'List all available' implies a read-only operation, but the description does not explicitly state safety (no side effects) or mention potential limitations like pagination or rate limits. For a straightforward list tool, the basic behavior is implied, but the description adds minimal context beyond what the tool's name suggests.
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, front-loaded with the main action ('List all available Pipedrive saved filters') immediately followed by practical use context. There is no redundant information, and every clause adds value. It is appropriately sized for a simple tool.
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's simplicity (one optional parameter, no output schema), the description covers the essential purpose, the use case, and the optional parameter. It lacks details about the exact return structure (e.g., fields beyond ID and name), but since the description explicitly mentions discovering IDs and names, it is reasonably complete. The context of sibling tools is clear, and the description enables effective tool selection without needing additional information.
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 has 100% coverage for the single optional 'type' parameter, which is fully described in the schema itself ('Optional filter type to narrow results.'). The description adds a small amount of value by repeating this option ('Optionally filter by type') but does not provide additional semantic detail such as how filtering affects results or examples. The baseline of 3 applies since schema coverage is high.
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 purpose with a specific verb and resource: 'List all available Pipedrive saved filters.' It distinguishes itself from sibling tools like miinta.filters.delete and miinta.filters.create by focusing on listing rather than mutation. The mention of discovering filter IDs and names clarifies the output's utility.
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 provides explicit context for when to use this tool: 'Useful for discovering filter IDs and names before calling miinta.sales_queue.get.' This gives a clear workflow guidance. It does not explicitly state when not to use it versus create/delete, but for a simple list tool, the usage context is sufficient and distinguishes from the sales_queue tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
miinta.sales_queue.getA
Return a structured "morning queue" payload using three Pipedrive filters (by ID or name), plus enrichment (deal title, stage name, org/person names, URLs). Use miinta.filters.list to discover available filter names.
| Name | Required | Description | Default |
|---|---|---|---|
| now | No | Optional ISO datetime override for deterministic testing | |
| limits | No | ||
| filters | Yes | ||
| timezone | No | Europe/Madrid | |
| include_people_orgs | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description alone must convey behavioral traits. It states the purpose (return a payload) and mentions enrichment, implying a read-only operation. However, it doesn't explicitly confirm no side effects, nor does it disclose error behavior, rate limits, or the impact of invalid filters. The mention of filter discovery hints at dependencies, but significant gaps remain.
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 exactly two sentences: the first states what the tool does with specific output details, the second gives a practical usage pointer. Every word adds value, no repetition, and the structure is efficient and front-loaded.
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 tool has a complex schema with nested objects and 5 parameters, yet there is no output schema. The description names the enriched fields but doesn't explain the queue structure, how filters map to sections, or the behavior of options like limits and timezone. It provides a high-level overview but lacks sufficient detail for an agent to confidently invoke it without further exploration.
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 only 20%, so the description needed to compensate by explaining parameters. It correctly mentions filters by ID or name, but this is already in the schema. It does not explain 'limits', 'timezone', 'include_people_orgs', or 'now', which are critical for using the tool correctly. The description adds minimal value beyond the schema for most 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 uses a specific verb 'Return' and a clear resource: a structured 'morning queue' payload. It details the mechanism (three Pipedrive filters) and enrichment fields, distinguishing it from sibling tools that manage filters (list, delete, create). This leaves no ambiguity about the tool's function.
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 explicitly tells users to use miinta.filters.list to discover available filter names, which is a clear prerequisite and points to the correct sibling tool for setup. It implies that filters must exist, but doesn't explicitly state when not to use this tool or mention alternatives for other queue-related needs. This is helpful but not exhaustive.
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.
4 tool updates
v0.1.0- First observed
miinta.filters.create - First observed
miinta.filters.delete - First observed
miinta.filters.list - First observed
miinta.sales_queue.get
TDQS
Each tool has a distinct purpose: list, create, delete filters, and get the sales queue. The sales queue tool depends on filters but does not overlap with filter CRUD operations. No ambiguity between tools.
All tools follow a consistent `miinta.<resource>.<action>` pattern: `miinta.filters.list`, `miinta.filters.delete`, `miinta.filters.create`, and `miinta.sales_queue.get`. The convention is uniform and predictable.
With four tools, the set is concise and well-scoped for managing filters and retrieving a sales queue. It fits within the ideal 3-15 range and each tool is necessary for the intended workflow.
Filter CRUD is partially covered: create, list, delete, but no update or get-by-id. The sales queue tool is the core feature and works via filters. Minor gaps exist but can be worked around by deleting/recreating filters.
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
API-first CRM for LLMs - contacts, companies, deals and activities over a native MCP server.
Cross-product MCP server for CRM, LeadKit, ProjectKit, Bookio. 10 action types, MIT open spec.
Pipedrive MCP Pack — wraps the Pipedrive REST API v1
Read-only MCP server for ClassQuill, a tutoring-business-management platform.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceUniversal MCP server for Pipedrive, enabling interaction with Pipedrive's tools and services through a standardized API.1MIT
- FlicenseNot gradedqualityDmaintenanceRead-only MCP server that exposes the Poli Júnior Pipedrive CRM to Claude as composable tools.-
- FlicenseNot gradedqualityBmaintenanceRead-only MCP server connecting Claude to Vtiger CRM for leads, deals, and overdue follow-ups.-
- AlicenseNot gradedqualityDmaintenanceMCP server for Pipedrive API v2, enabling management of deals, persons, organizations, products, activities, and pipelines through natural language in MCP clients like Cursor and Claude Desktop.932MIT
Appeared in Searches
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/alvarolloret/pipedrive-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server