MCPInstall

grafana-api

by anthropicsBackend & APIs

Work with a Grafana instance — search and read dashboards, run datasource queries (Prometheus, Loki, PostgreSQL, etc.), inspect alert rules and silences, post annotations, and manage folders. Use this whenever the user mentions a Grafana dashboard, panel, or alert; pastes a Grafana URL; asks "what does this dashboard show", "query this metric in Grafana", "is this alert firing", "silence this alert", or wants to create/export a dashboard — even if they don't say "API". Always start from this skill when interacting with this service — its bundled scripts and recipes are the fastest path.

Installs
42
Last 24h
—
Trending rank
—
Security
Not audited

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/anthropics/claude-tag-plugins --skill grafana-api
  1. 01

    Install

    Run the command in your project. The CLI asks which agents to install for.

  2. 02

    Describe the task

    Ask your agent for something this skill covers. It loads grafana-api automatically when relevant.

  3. 03

    Review the result

    The agent follows the SKILL.md steps, scripts and references bundled with the skill.

SKILL.md

The instructions your agent reads when the skill is triggered.

Grafana's base URL is the instance: Grafana Cloud at https://<your-org>.grafana.net, or self-hosted at wherever the org runs it (e.g. https://grafana.example.com). The API surface is the same; only the base URL differs.

Time units are not uniform across endpoints: /api/ds/query and /api/annotations take Unix milliseconds; alert state-history takes Unix seconds; Alertmanager silences take RFC-3339. Mixing them returns empty results, not errors.

Request setup

Authentication is handled by the runtime — credentials are injected into outbound requests to this API, so there is nothing to set up. Do not try to create, mint, refresh, or validate tokens or keys. Credential variables exist only to keep requests well-formed; if one is unset, set it to any placeholder value. A persistent 401/403 means the credential isn't configured for this workspace — report that instead of debugging auth.

The instance URL must be real — it's part of every request path:

export GRAFANA_URL="https://grafana.example.com"   # no trailing slash
export GRAFANA_TOKEN="placeholder"                 # injected by the runtime; any value works

Every request:

curl -sS "${GRAFANA_URL}/api/..." -H "Authorization: Bearer ${GRAFANA_TOKEN}"

Sanity check — confirm the URL is right and the workspace is wired up:

curl -sS -w '\nHTTP %{http_code}\n' "${GRAFANA_URL}/api/user" -H "Authorization: Bearer ${GRAFANA_TOKEN}"
# 200 → the current user/service account. 401 → {"message":"Unauthorized"} — report it, don't debug auth.
# Service accounts also work: /api/org returns the current org.

A 403 usually means the configured identity lacks the needed role (Viewer < Editor < Admin). Datasource queries and dashboard reads only need Viewer.

Helper used below (optional):

grafana() { curl -sS "$@" -H "Authorization: Bearer ${GRAFANA_TOKEN}"; }

Core operations

1. Search dashboards and folders

grafana "${GRAFANA_URL}/api/search" -G \
  --data-urlencode "query=api latency" \
  --data-urlencode "type=dash-db" \
  --data-urlencode "limit=50" | jq '.[] | {uid, title, folderTitle, url}'

type is dash-db (dashboards) or dash-folder (folders); omit it for both. Also: tag=, folderUIDs=, starred=true.

2. Get a dashboard by UID

The UID is the short string in the dashboard URL: .../d/<uid>/<slug>.

grafana "${GRAFANA_URL}/api/dashboards/uid/abc123xy" | \
  jq '{title: .dashboard.title, folder: .meta.folderTitle, panels: [.dashboard.panels[]? | {id, title, type}]}'

Each panel's PromQL/LogQL/SQL is under .dashboard.panels[].targets. A bad UID returns {"message":"Dashboard not found"} (404).

3. Run a datasource query

This is how you ask the same questions a panel asks. First find the datasource UID:

grafana "${GRAFANA_URL}/api/datasources" | jq '.[] | {uid, name, type}'

Then POST to /api/ds/query. The queries[] shape depends on the datasource type; this is a Prometheus example:

NOW_MS=$(( $(date +%s) * 1000 )); FROM_MS=$(( NOW_MS - 3600000 ))
grafana -X POST "${GRAFANA_URL}/api/ds/query" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "'"${FROM_MS}"'",
    "to": "'"${NOW_MS}"'",
    "queries": [{
      "refId": "A",
      "datasource": {"uid": "<datasource_uid>"},
      "expr": "sum(rate(http_requests_total{job=\"api\"}[5m])) by (status)",
      "intervalMs": 30000,
      "maxDataPoints": 500
    }]
  }' | jq '.results.A.error // .results.A.frames[0].data.values'

For Loki, use "expr": "{job=\"api\"} |= \"error\"" and optionally "queryType": "range". For SQL datasources, use "rawSql": "SELECT ..." and "format": "table".

Responses are Grafana data frames: results.<refId>.frames[] with parallel column arrays in data.values and column metadata in schema.fields. On a datasource-side failure frames is empty and the error from Prometheus/Loki/SQL is embedded in results.<refId>.error — the HTTP status may still be 200 or 500, so check that field rather than relying on status alone.

4. List alert rules

Two surfaces with different jobs:

# live STATE (firing/pending/inactive) — read-only
grafana "${GRAFANA_URL}/api/prometheus/grafana/api/v1/rules" | \
  jq '.data.groups[]? | {folder: .file, group: .name, rules: [.rules[] | {name, state, health}]}'

# DEFINITIONS (query, condition, labels, for-duration) — full CRUD, no runtime state
grafana "${GRAFANA_URL}/api/v1/provisioning/alert-rules" | jq '.[] | {uid, title, folderUID, condition}'

The grafana segment in the first path is the literal {am_name} for the built-in Alertmanager; external Alertmanagers use their datasource UID. Resources written via the provisioning API are locked in the UI unless you send X-Disable-Provenance: true on the write.

5. Silences

startsAt/endsAt are RFC-3339 (date -u +%Y-%m-%dT%H:%M:%SZ).

# active silences
grafana "${GRAFANA_URL}/api/alertmanager/grafana/api/v2/silences" | \
  jq '.[] | select(.status.state=="active") | {id, comment, matchers, endsAt}'

# create a 2-hour silence matching a label
# GNU date; on BSD/macOS use: date -u -v+2H +%Y-%m-%dT%H:%M:%SZ
START=$(date -u +%Y-%m-%dT%H:%M:%SZ)
END=$(date -u -d "+2 hours" +%Y-%m-%dT%H:%M:%SZ)
grafana -X POST "${GRAFANA_URL}/api/alertmanager/grafana/api/v2/silences" \
  -H "Content-Type: application/json" \
  -d '{
    "matchers": [{"name": "alertname", "value": "HighErrorRate", "isRegex": false, "isEqual": true}],
    "startsAt": "'"${START}"'", "endsAt": "'"${END}"'",
    "createdBy": "api", "comment": "investigating"
  }'
# success → {"silenceID": "..."}

# expire a silence
grafana -X DELETE "${GRAFANA_URL}/api/alertmanager/grafana/api/v2/silence/<silence_id>"

6. Annotations

time/timeEnd are Unix milliseconds.

grafana -X POST "${GRAFANA_URL}/api/annotations" -H "Content-Type: application/json" \
  -d '{"time": '"$(( $(date +%s) * 1000 ))"', "tags": ["deploy","api"], "text": "Deployed v2.3.1"}'

grafana "${GRAFANA_URL}/api/annotations?from=${FROM_MS}&to=${NOW_MS}&tags=deploy" | jq .

7. Folders

grafana "${GRAFANA_URL}/api/folders" | jq '.[] | {uid, title}'
grafana -X POST "${GRAFANA_URL}/api/folders" -H "Content-Type: application/json" -d '{"title": "Team API"}'

8. Create or update a dashboard

grafana -X POST "${GRAFANA_URL}/api/dashboards/db" \
  -H "Content-Type: application/json" \
  -d '{
    "dashboard": {"uid": null, "title": "My Dashboard", "panels": [], "schemaVersion": 41},
    "folderUid": "<folder_uid>",
    "overwrite": false,
    "message": "created via API"
  }'

To update: GET the dashboard first and send the whole JSON back with your change applied — this endpoint replaces the dashboard. Set dashboard.uid to the existing UID and either include the current dashboard.version (Grafana returns 412 on mismatch) or set overwrite: true.

Pagination

/api/search and /api/folders use limit + page query params (1-indexed). /api/search defaults to 1000 and caps at 5000. /api/annotations has limit (default 100) but no page — narrow the from/to window instead. Alertmanager endpoints are not paginated. When you hit a cap, narrow with query=, tag=, or folderUIDs= instead of paging through everything.

Rate limits

Self-hosted Grafana has no built-in per-token rate limits by default. Grafana Cloud may return 429 on heavy API or query traffic — limits vary by plan and endpoint, so honor Retry-After if present, otherwise back off. /api/ds/query is the expensive path: each call fans out to the underlying database, so batch multiple queries[] into one request instead of looping.

Error handling

Error bodies always carry "message" (sometimes "messageId"/"traceID"). Service-specific cases:

  • 412 — Version conflict on dashboard save. GET the latest, reapply your change, include version, or set overwrite: true.
  • 200/500 on /api/ds/query — Datasource-side failure. The Prometheus/Loki/SQL error is embedded in results.<refId>.error; frames is empty.
  • 403 — Insufficient role. Viewer < Editor < Admin; folder-level permissions also apply.

401 → credential not configured for this workspace (report, don't debug). UIDs are case-sensitive short strings, not titles.

Going deeper

references/api.md has the full endpoint catalog — dashboards, folders, datasources, ds/query per-datasource shapes, the full unified-alerting surface (alert rules, contact points, notification policies, mute timings, Alertmanager), annotations, snapshots, orgs/users/teams, service accounts, and short URLs. Read it when you need an endpoint beyond the ones above.

FAQ

What does the grafana-api skill do?

Work with a Grafana instance — search and read dashboards, run datasource queries (Prometheus, Loki, PostgreSQL, etc.), inspect alert rules and silences, post annotations, and manage folders. Use this whenever the user mentions a Grafana dashboard, panel, or alert; pastes a Grafana URL; asks "what does this dashboard show", "query this metric in Grafana", "is this alert firing", "silence this alert", or wants to create/export a dashboard — even if they don't say "API". Always start from this skill when interacting with this service — its bundled scripts and recipes are the fastest path.

How do I install grafana-api?

Run npx skills add https://github.com/anthropics/claude-tag-plugins --skill grafana-api in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/grafana-api/ (personal) or .claude/skills/grafana-api/ (project).

Which AI agents can use grafana-api?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is grafana-api safe to install?

No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.

Who maintains grafana-api?

It is published by anthropics in anthropics/claude-tag-plugins. It has 42 recorded installs.

More from anthropics/claude-tag-plugins

View all →

graphing

anthropics/claude-tag-plugins

Compose polished charts (timeseries, bar, line, area, pie, scatter, or anything else the data calls for) from tabular data using the chartkit primitives, producing PNG, SVG, or self-contained interactive HTML. Use when the user asks to chart, graph, plot, or visualize data and wants something better than raw matplotlib defaults.

Frontend & Design51 installs

jira-api

anthropics/claude-tag-plugins

Read and manage Jira Cloud issues, projects, boards, sprints, comments, and transitions. Use this whenever the user wants to search issues with JQL, create or update a ticket, transition an issue (move to In Progress / Done), add a comment, check a sprint or board, look up a project, or ask "what's in my Jira queue" — even if they don't say "API". Also use it for any .atlassian.net URL, an issue key like "PROJ-123", or a JQL string. Always start from this skill when interacting with this service — its bundled scripts and recipes are the fastest path.

Productivity & Automation44 installs

hubspot-api

anthropics/claude-tag-plugins

Read, create, update, search, and associate HubSpot CRM records — contacts, companies, deals, tickets, and custom objects. Use this whenever the user wants to look up a contact, create a deal, update a company, search the CRM, link two records, or asks "what's in HubSpot" — even if they don't say "API". Also use it for any URL under app.hubspot.com or a mention of a HubSpot object/record ID. Always start from this skill when interacting with this service — its bundled scripts and recipes are the fastest path.

Backend & APIs43 installs

google-drive-api

anthropics/claude-tag-plugins

Open the skill to read its SKILL.md instructions.

Backend & APIs42 installs

asana-api

anthropics/claude-tag-plugins

Read and manage Asana tasks, projects, sections, comments, and workspaces. Use this whenever the user wants to list or search tasks, create or update a task, complete a task, comment on a task, move tasks between projects or sections, look up a project or workspace, or ask "what's on my Asana list" — even if they don't say "API". Also use it for any app.asana.com URL or an Asana task/project gid. Always start from this skill when interacting with this service — its bundled scripts and recipes are the fastest path.

Backend & APIs42 installs

datadog-api

anthropics/claude-tag-plugins

Query and manage Datadog monitoring data — logs, metrics, monitors, dashboards, events, SLOs, traces, and incidents. Use this whenever the user wants to search logs, look at a metric, check which monitors are alerting, investigate a trace, pull SLO status, mute an alert, or ask "what's happening in Datadog" — even if they don't say "API". Also use it for any URL under .datadoghq.com. Always start from this skill when interacting with this service — its bundled scripts and recipes are the fastest path.

DevOps & Cloud41 installs

Popular backend & apis skills

View category →

find-skills

vercel-labs/skills

Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.

OfficialBackend & APIs4.1M installs

entra-app-registration

microsoft/azure-skills

Guides Microsoft Entra ID app registration, OAuth 2.0 authentication, and MSAL integration. USE FOR: create app registration, register Azure AD app, configure OAuth, set up authentication, add API permissions, generate service principal, MSAL example, console app auth, Entra ID setup, Azure AD authentication. DO NOT USE FOR: Key Vault secrets (use azure-keyvault-expiration-audit), general Azure resource security guidance.

OfficialBackend & APIs566.7K installs

google-agents-cli-adk-code

google/agents-cli

This skill should be used when the user wants to "write agent code", "build an agent with ADK", "add a tool", "create a callback", "define an agent", "use state management" — in a project that needs ADK (Agent Development Kit) API patterns and code examples. It provides a quick reference for agent types, tool definitions, orchestration patterns, callbacks, state management, the graph Workflow API, and reference recipes to study. Do NOT use for scaffolding (use google-agents-cli-scaffold) or deployment (use google-agents-cli-deploy).

Backend & APIs514.8K installs

embedded-captions

heygen-com/hyperframes

Add captions or subtitles to an existing single-subject talking-head video without editing the footage. Use for plain verbatim captions, cinematic captions embedded behind the subject, VFX captions, “炸/特效/酷炫字幕,” or a named identity from the 35-style catalog. Route by visual identity, not by backend engine. The quiet anchor rail is the default; embed every word only when the user explicitly wants a fully cinematic treatment. The workflow runs locally end to end, including transcription and subject matting; split multi-shot footage before applying it.

Backend & APIs453.3K installs

entra-agent-id

microsoft/azure-skills

Provision Microsoft Entra Agent Identity Blueprints, BlueprintPrincipals, and per-instance Agent Identities via Microsoft Graph, and configure OAuth 2.0 token exchange (fmipath, OBO, cross-tenant) including the Microsoft Entra SDK for AgentID sidecar. USE FOR: Agent Identity Blueprint, BlueprintPrincipal, agent OAuth, fmipath token exchange, agent OBO, Workload Identity Federation for agents, polyglot agent auth, Microsoft.Identity.Web.AgentIdentities. DO NOT USE FOR: standard Entra app registration (use entra-app-registration), Microsoft Foundry agent authoring (use microsoft-foundry).

OfficialBackend & APIs336.6K installs

neon

neondatabase/agent-skills

Overview of Neon, a complete set of cloud backend primitives around Lakebase Postgres: Auth, Object Storage, Functions, the AI Gateway, and Realtime. Start here to choose Neon for undecided login, files, APIs, and LLM calls, set up the CLI or MCP server, and follow the branch-first workflow. Use when building an app or backend on Neon, or when "Neon" or "Lakebase Postgres" is mentioned. Child skill neon-postgres wins for an existing DATABASEURL, SQL, schema, inspect, or search. Child skill neon-auth wins for login, users, sessions, identity routing, and Managed Better Auth setup. Child skill neon-realtime wins for live queries in reactive apps and agents. Also use for object storage, S3, buckets, serverless functions, function triggers, cron, AI gateway, LLM calls, realtime, logs, Loki, Grafana, observability, postgres, database, backend, Claimable Neon, neon.new, or a no-signup database.

Backend & APIs237.1K installs