Skip to main content

Using MCP tools as an Open API

Use Polar API — via the Model Context Protocol (MCP) — as an open API, detailing available endpoints, authentication, and a quick-start workflow for generating reports and accessing dashboard data.

Written by Kellie Reese
Updated yesterday

Overview

Polar MCP tools let you access dashboards, reports, and analytics data programmatically from your Polar workspace. This is useful when you want to connect Polar to automation platforms, internal tools, AI agents, or workflows that need analytics on demand rather than through the UI alone. The current documentation positions Generate Report as the main endpoint most developers will use, with additional supporting endpoints for context, dashboards, dimensions, views, report links, and feedback.

In this article, you will learn:

  • what Polar MCP tools are and when to use them

  • how to generate and authorize API access

  • how to call Polar MCP tools step by step

  • which endpoints matter most

  • how to build a practical workflow from discovery to reporting

Section 1: What Polar MCP tools are and when to use them

Polar MCP tools expose Polar functionality through API-style endpoints so you can retrieve analytics outputs from code or automations instead of navigating the app manually. This gives you programmatic access to dashboards, reports, and analytics data from a Polar workspace.

This is especially useful for teams that want to:

  • generate reports from scripts or backend services

  • plug Polar into agentic workflows

  • send analytics results into Slack, internal dashboards, or orchestration tools

  • standardize reporting across teams and systems

Polar MCP tools give you an API layer for Polar reports and metadata.
You can use them to discover what exists in your workspace, select the right dashboard or view, and generate report output programmatically.

Generate Report is the primary endpoint most developers will use.

The simplest mental model is:

  1. Authenticate

  2. Understand your workspace context

  3. Find the right dashboard or view

  4. Run Generate Report

  5. Use or share the result

Section 2: Authentication and quick start

To begin, you will need to generate an API key from the Polar MCP page in the app, then send it as a Bearer token in the Authorization header for all requests. The base URL is https://api.polaranalytics.com/mcp and the tool pattern is POST https://api.polaranalytics.com/mcp/tool/<tool_name>.

Prerequisites

Before using MCP tools, you should have:

  • access to a Polar workspace

  • permission to open the Polar MCP page

  • an API key generated from that page

  • a tool or environment that can make HTTPS POST requests, such as cURL, Postman, a backend service, or an automation platform

Authorization details

How to get your API key

  1. Open the Polar app.

  2. Go to Polar MCP.

  3. Generate or copy your API key.

How to authenticate requests
Send the API key in the header below for every request:

Authorization: Bearer <YOUR_API_KEY>

Base URL

https://api.polaranalytics.com/mcp

Tool endpoint pattern

POST https://api.polaranalytics.com/mcp/tool/<tool_name>

Quick start example

You can show a first-request pattern like this:

curl -X POST "https://api.polaranalytics.com/mcp/tool/<tool_name>" \
  -H "Authorization: Bearer <YOUR_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{}'

Keep your API key secure. Do not expose it in frontend code, public repos, or client-side scripts. Store it in your server environment or secret manager and rotate it if you believe it has been compromised.

Quick start

  1. Generate an API key in Polar MCP.

  2. Add the key as a Bearer token in your request headers.

  3. Start with the workspace discovery endpoints if you need to identify dashboards, dimensions, or views.

  4. Use Generate Report once you know what report you want.

  5. Optionally send the output into Slack or another destination in your automation flow.

Section 3: Core workflow and key endpoints

Step 1: Get workspace context

Use Get Context to understand the account or workspace context your requests should operate within. This is helpful when your workflow needs environment awareness before selecting assets.

Step 2: Discover available dashboards

Use List Dashboards to retrieve the dashboards available in your workspace.

Step 3: Inspect a dashboard

Use Get Dashboard Details when you’ve identified a dashboard and want more detail before choosing a reportable asset.

Step 4: Explore available dimensions

Use List Dimensions when your report needs breakdowns such as channel, source, region, or another business dimension.

Step 5: Inspect a specific view

Use Get View Details to verify the exact view configuration before generating data from it.

Step 6: Generate the report

Use Generate Report as the main execution step. The current article explicitly highlights this as the primary endpoint for most developers.

Step 7: Generate a shareable report link

Use Generate Report Link when you want to turn a generated report into something easier to distribute.

Step 8: Rate the report

Use Rate Report to provide feedback on the generated output if your workflow includes quality review or system feedback loops.

Section 4: Step-by-step example workflow

Goal: Retrieve orders by sales channel and send the output into an automated workflow.

End-to-end steps

  1. Generate your API key in the Polar MCP page.

  2. Store the key securely in your automation platform, backend, or secret manager.

  3. Call Get Context to confirm the workspace context.

  4. Call List Dashboards to identify the relevant dashboard.

  5. Call Get Dashboard Details if you need more metadata to find the right view.

  6. Call List Dimensions to confirm the dimension you want, such as sales channel.

  7. Call Get View Details to verify the target view and its structure.

  8. Call Generate Report with the parameters for your chosen view and breakdown.

  9. Optionally call Generate Report Link to create a sharable artifact.

  10. Send or store the output in Slack, your internal system, a spreadsheet, or downstream analytics workflow.

You can use Polar MCP tools as a lightweight open API for reporting workflows. A common pattern is to first discover the workspace structure, then generate a report once you know which dashboard, view, and dimensions to use. For example, a team that wants orders by sales channel can authenticate with an API key, inspect available dashboards and dimensions, then run Generate Report and post the result to Slack.

Section 5: Troubleshooting and implementation tips

Common issues

401 or unauthorized

  • Confirm you generated the API key from the Polar MCP page.

  • Make sure the header format is exactly:
    ​ Authorization: Bearer <YOUR_API_KEY>

Wrong tool path

Can’t find the right report

  • Start with discovery endpoints first: Get Context, List Dashboards, Get Dashboard Details, List Dimensions, and Get View Details. These are listed in the current article as supporting endpoints.

Workflow succeeds but output isn’t useful

  • Verify the dashboard/view you selected matches the business question.

  • Check dimensions and filters before generating the report.

  • If needed, generate a report link for easier review and sharing.

Implementation tips

  • Start with one narrow reporting use case before scaling to a broader automation system.

  • Use backend or server-side environments to protect your API key.

  • Keep endpoint wrappers modular so you can swap discovery and generation steps easily.

  • Log request IDs and tool names for easier debugging.

Full example with curl and jq

#!/bin/bash

BASE="https://api.polaranalytics.com/mcp/tool"
API_KEY="<YOUR_API_KEY>"

# Tools require a question for logging purposes, just enter something like 'daily sales figures'
YOUR_QUESTION="<YOUR_QUESTION>"

# Helper: POST to a tool endpoint, parse the nested response
rpc() {
  curl -s -X POST "$BASE/$1" \
    -H "Authorization: Bearer $API_KEY" \
    -H "Content-Type: application/json" \
    -d "$2" \
  | jq -r '.content[0].text' | jq .
}

# Step 1: get_context
CONTEXT=$(rpc "get_context" "{\"initialQuestion\": \"$YOUR_QUESTION\", \"version\": \"3.2\"}")
CONVERSATION_ID=$(echo "$CONTEXT" | jq -r '.conversation_id')
echo "Conversation ID: $CONVERSATION_ID"

# Step 2: get_metrics (needed to confirm metric keys)
rpc "get_metrics" "{
  \"conversation_id\": \"$CONVERSATION_ID\",
  \"connectorList\": \"shopify\"
}" > /dev/null

# Step 3: generate_report
rpc "generate_report" "{
  \"conversation_id\": \"$CONVERSATION_ID\",
  \"metrics\": \"shopify_sales_main.raw.gross_sales\",
  \"dimensions\": \"\",
  \"dateRangeFrom\": \"2026-03-01\",
  \"dateRangeTo\": \"2026-03-16\",
  \"granularity\": \"day\",
  \"ordering\": \"date:ASC\",
  \"rules\": \"{}\",
  \"metricRules\": \"{}\",
  \"settings\": \"{}\",
  \"reflexion\": \"$YOUR_QUESTION\"
}" | jq '{total: .totalData, table: .tableData}'

Conclusion

Polar MCP tools make it possible to use Polar as an open API layer for dashboards and reporting. Customers can authenticate with an API key from the Polar MCP page, call MCP tool endpoints through the shared base URL, and use supporting discovery endpoints before executing the main Generate Report action.

For most readers, the key takeaway is simple:
​ authenticate once, discover the right dashboard/view, then use Generate Report to bring Polar data into your workflows.

FAQ

Do I need all MCP endpoints to get started?

No. The current documentation says most developers will primarily use Generate Report. The supporting endpoints help you discover context, dashboards, dimensions, and views first.

How do I authenticate?

Generate an API key in the Polar MCP page and send it as a Bearer token in the Authorization header.

What is the base URL?

https://api.polaranalytics.com/mcp

How do I call a tool?

Send a POST request to:
​ https://api.polaranalytics.com/mcp/tool/<tool_name>

Related Articles
Installing the Polar MCP
Use Polar MCP in n8n (with Gmail)
Installing the Polar MCP with n8n (with Slack)
Use Polar MCP in Make
Use Polar MCP in lovable
Did this answer your question?