# Paymo MCP > Paymo connects your AI client to the Paymo Project Platform, giving you one central place for managing agency workflows. You can use it to trace tasks, log time entries against specific clients, list project milestones, and fetch secure invoice data using structured prompts. It handles everything from initial task creation via `create_task` to detailed billing extraction with `list_invoices`. This is the single endpoint you need to keep your client's operational data current. ## Overview - **Category:** productivity - **Price:** Free - **Tags:** time-tracking, billing, invoicing, milestone-tracking, task-management, resource-planning ## Description Paymo gives your AI client a direct line into the Paymo Project Platform. You don't gotta mess with some clunky web portal; you just run commands, and we spit out structured data—JSON arrays—that your workflow can use right away. This single endpoint handles everything from tracking down who works on what to pulling current invoice numbers. **CORE PROJECT SCOPE AND SETUP** You start by mapping out the client's whole setup. You'll run `list_clients` to grab an array of every active client ID in your agency. To see which projects are running, call `list_projects`; that returns a list of all current project IDs and their associated client bindings. If you need deep details on one specific job, use `get_project_details`. It pulls deep info about a single project ID, including its boundaries and every client attached to it. You can also run `list_users` to get an array listing every user identity tied to your agency's accounts. **TASK AND MILESTONE MANAGEMENT** When you need to track work or set goals, these tools are what you use. To see a full log of existing tasks against a specific client or project ID, run `list_tasks`. If you gotta kick off a new job, `create_task` accepts parameters and dispatches that new task instance, validating its boundaries and owners across the platform. You can also check on predefined targets by calling `list_milestones`; this shows when key deliverables are scheduled or marked as complete. Remember to use `list_projects` and `list_clients` together if you're trying to trace which tasks or milestones belong where. **LOGGING TIME AND BILLING DATA** This is where the money comes in, so pay attention. To track hours worked, you first grab a complete list of recorded time entries by running `list_time_entries`. If you need to log new time, use `create_time_entry`; it takes specific parameters and assigns those hours against an existing task or client ledger while confirming the assignment against project and user boundaries. For billing, you pull structural data for active records using `list_invoices`, which shows amounts due and current status across multiple invoices. You're always keeping track of who logged time and when by checking that full history list. **SUMMARY OF WORKFLOWS** * To verify the whole scope, run `list_clients` then use the resulting IDs in `list_projects`. * Need to start a new piece of work? You validate boundaries first with `get_project_details`, then you dispatch it using `create_task`. * When someone finishes hours, they log it via `create_time_entry`, and you check the full history using `list_time_entries`. * To make sure you get paid, run `list_invoices`; that gives you all the status updates and amounts due across your active billing records. It's a straight shot from operational data to financial reality. ## Tools ### list_projects Returns a list of all active projects, including their primary IDs and associated client bindings. ### get_project_details Retrieves deep, specific information about a single project ID, including its associated clients and boundaries. ### list_tasks Retrieves an explicit log of existing tasks by listing them against a specific project or client ID. ### create_task Sends a new task to the system after validating all necessary project bounds are present. ### list_time_entries Generates a full list of recorded time entries, detailing who logged hours and when the work occurred. ### create_time_entry Logs time by accepting parameters and assigning hours against an existing task or client ledger. ### list_invoices Pulls structural data for billing records, showing status and amounts due across multiple invoices. ### list_clients Returns an array listing all active client IDs used within the Paymo system. ### list_users Returns an array listing every user identity associated with your agency's accounts. ### list_milestones Inspects predefined project targets to show when key deliverables are scheduled or completed. ## Prompt Examples **Prompt:** ``` List all explicitly active projects returning limits logged statically across Paymo. ``` **Response:** ``` Queried projects effectively isolating states. Validated 2 explicit configurations. 1. 'Mobile Revamp' (ID 43xx) tied strictly to Client 90x. 2. 'Backend MLOps Pipeline' explicitly mapped limits. Require granular task extraction natively on #1? ``` **Prompt:** ``` Capture explicit parameters checking active invoices mapped securely under my agency. ``` **Response:** ``` Valid REST logic intercepted mapping results fetching `list_invoices`. Extracted JSON natively bound limits tracking two invoices. INV-034: Due logic active, $1,500 status sent gracefully. Would you like me to dump pure JSON outputs explicitly tracking limits? ``` **Prompt:** ``` Log exactly 2 explicit bounds securely mapping '4 hours' worked on task ID t88x. ``` **Response:** ``` Passed JSON commands explicitly natively validating insertion logic cleanly in Paymo arrays running background logic. Logged exactly exactly '240 minutes' natively (4 hrs). The pipeline recorded constraints tied properly to task bounds successfully. ``` ## Capabilities ### Log Time Entries The server accepts specific inputs to record hours worked, verifying the assignment against defined project and user boundaries. ### Fetch Invoice Data It performs a structured query that returns active billing records, including due dates and current status parameters for multiple invoices. ### Identify Clients The server runs against the native CRM to return an array of all currently active client identities used in your agency's projects. ### Map Project Boundaries It inspects deep internal arrays, providing a list of existing project configurations and their associated IDs within Paymo. ### Create Tasks The server accepts parameters to dispatch a new task instance, assigning it explicit boundaries and owners mapped across the platform. ## Use Cases ### End-of-Month Billing Review The Account Manager needs to know if a client is overdue. They ask their agent: 'Get me all invoices for Client X.' The agent runs `list_invoices`, which returns the JSON payload, instantly showing the status and due dates without visiting the billing section of Paymo. ### Onboarding New Consultant A new consultant needs to start tracking time. Instead of logging into a separate portal, they tell their agent: 'Log 8 hours for Project Alpha.' The agent executes `create_time_entry`, passing the necessary task and user IDs directly from the chat interface. ### Checking Deliverables Status The Founder needs to know if Milestone 3 is ready. They prompt: 'What are the current project milestones for Client Y?' The agent runs `list_milestones`, providing a clean list of status checkpoints, ensuring nothing was missed before billing starts. ### Project Scope Definition The team needs to scope out new work. They ask the agent to check project limits: 'List all active projects and their clients.' The agent runs `list_projects` and then cross-references it with `list_clients`, giving a complete map of current boundaries. ## Benefits - **Billing Visibility:** Never manually hunt for invoices again. Call `list_invoices` to get a structured array of all active bills and their status in one API call. - **Audit Trail:** Track exactly where the hours went. Use `list_time_entries` combined with `get_project_details` to build a comprehensive, auditable log of work for any client period. - **Task Coordination:** Don't forget critical steps. Call `create_task` to assign a follow-up item or use `list_tasks` to confirm all necessary project tasks are logged against the current milestone. - **Client Mapping:** Stop guessing which client ID belongs where. Run `list_clients` first; this gives you a clean, definitive list of every active account in your system. - **Project Health Check:** Quickly assess overall project status. `list_projects` provides an immediate overview of all configured work streams and their associated clients. ## How It Works The bottom line is, you don't write code; you just ask questions through your AI client, and we give you the structured answers from Paymo. 1. First, your AI client sends a structured request specifying which data you need (e.g., 'Show me all active invoices for Client ID 123'). 2. The Paymo MCP Server validates the request against its internal logic and executes the corresponding API tool call. 3. You receive a clean, JSON-formatted response containing only the requested data points, ready for your agent to act on. ## Frequently Asked Questions **How do I use create_task to start tracking new work?** You call `create_task` with the necessary parameters: the Project ID, Client ID, and target User IDs. The server validates these bounds before logging the task into Paymo. **What is the best tool for checking all active client accounts? list_clients?** `list_clients` runs a query against your CRM to return an array of every single active Client ID. This is the definitive source you use before running any other client-specific function. **Does list_invoices show me only paid bills or all bills?** It pulls structural data for *active* billing records, meaning it shows everything from draft status through pending payments. It’s your full financial picture. **Can I use get_project_details to find out who worked on the project?** While `get_project_details` gives you the overall scope, you should run `list_time_entries` for a definitive list of workers and hours logged against that specific project. **What authentication requirements does running list_projects need?** You must supply a valid Paymo API token. If your token lacks read permissions, the call fails immediately and returns an HTTP 401 error code. Always validate your token scope before running any listing commands. **When I use list_time_entries, can I limit the results by a specific date range?** Yes, you pass optional start and end date parameters to narrow the payload. The tool limits fetching to 100 entries per call by default; always expect pagination for large data sets. **If I use create_task but the task ID already exists, does it fail?** No, running create_task with an existing unique identifier triggers a soft validation. The API returns success and simply reports that the record is already present. **Does list_tasks provide enough context to link tasks back to a specific client?** The task objects contain explicit foreign keys for both Project ID and Client ID. This lets your agent cross-reference the data without needing separate calls to list_clients. **How exactly does the AI log time tracking entries to a task?** Through explicit invocation by pushing bounds mapped securely over `create_time_entry`. You instruct exactly 'Add 2 hours for task XY', and the node bridges those limits pushing explicitly into the structural API. **Are milestone objects connected to project extractions natively?** Yes. When extracting specific metadata loops using list queries, milestones return explicit JSON bounds resolving the connected project parent limits gracefully revealing dates strictly. **Can it trace users and identify the ID mapped over each collaborator logically?** Absolutely, dispatching `list_users` isolates parameters matching team structures natively to evaluate specific user metadata IDs reliably required by other explicit creation blocks.