Skip to main content
Glama
Datawrapper MCP

Datawrapper MCP

by hqu

A Model Context Protocol (MCP) server that enables AI assistants to create Datawrapper charts. Built on the datawrapper Python library with Pydantic validation.

Example Usage

Here's a complete example showing how to create, publish, update, and display a chart by chatting with the assistant:

"Create a datawrapper line chart showing temperature trends with this data:
2020, 15.5
2021, 16.0
2022, 16.5
2023, 17.0"
# The assistant creates the chart and returns the chart ID, e.g., "abc123"

"Publish it."
# The assistant publishes it and returns the public URL

"Update chart with new data for 2024: 17.2°C"
# The assistant updates the chart with the new data point

"Make the line color dodger blue."
# The assistant updates the chart configuration to set the line color

"Show me the editor URL."
# The assistant returns the Datawrapper editor URL where you can view/edit the chart

"Show me the PNG."
# The assistant embeds the PNG image of the chart in its contained response.

"Suggest five ways to improve the chart."
# See what happens!

Related MCP server: holoviz-viz-mcp

Getting Started

Requirements

Get Your API Token

  1. Go to https://app.datawrapper.de/account/api-tokens

  2. Create a new API token

  3. Add it to your MCP configuration as shown below

Installation

Claude Code

Using uvx (recommended)

Configure your MCP client in claude_desktop_config.json:

{
  "mcpServers": {
    "datawrapper": {
      "command": "uvx",
      "args": ["datawrapper-mcp"],
      "env": {
        "DATAWRAPPER_ACCESS_TOKEN": "your-token-here"
      }
    }
  }
}

Using pip

First install the package:

pip install datawrapper-mcp

Then configure your MCP client in claude_desktop_config.json:

{
  "mcpServers": {
    "datawrapper": {
      "command": "datawrapper-mcp",
      "env": {
        "DATAWRAPPER_ACCESS_TOKEN": "your-token-here"
      }
    }
  }
}

OpenAI Codex

CLI with uvx

Add this to ~/.codex/config.toml:

[mcp_servers.datawrapper]
args = ["datawrapper-mcp"]
command = "uvx"
startup_timeout_sec = 30

[mcp_servers.datawrapper.env]
DATAWRAPPER_ACCESS_TOKEN = "your-token-here"

CLI with pip

First install the package:

pip install datawrapper-mcp

Then add this to ~/.codex/config.toml:

[mcp_servers.datawrapper]
command = "datawrapper-mcp"
startup_timeout_sec = 30

[mcp_servers.datawrapper.env]
DATAWRAPPER_ACCESS_TOKEN = "your-token-here"

Secure secrets

For enhanced security, you can configure a pass-through environment variable by ensuring that DATAWRAPPER_ACCESS_TOKEN is set in your environment, and replacing this in your config.toml:

[mcp_servers.datawrapper.env]
DATAWRAPPER_ACCESS_TOKEN = "your-token-here"

With this:

env_vars = ["DATAWRAPPER_ACCESS_TOKEN"]

This ensures that the value set for DATAWRAPPER_ACCESS_TOKEN in your environment is passed through to Codex without having to store the secret as text in a config file.

Desktop application

If you're using the Codex Desktop Application, you can set up the MCP in your settings under MCP servers:

  1. Under Custom servers, click Add server

  2. Under Name, enter datawrapper-mcp

  3. Select STDIO

  4. Under Command to launch, type uvx (you must have uv installed)

  5. Under Arguments, add datawrapper-mcp

  6. Under Environment variables, add DATAWRAPPER_ACCESS_TOKEN as the key and your token as the value

  7. Click Save

Kubernetes Deployment

For enterprise deployments, this server can be deployed to Kubernetes using HTTP transport:

Building the Docker Image

docker build -t datawrapper-mcp:latest .

Running with Docker

docker run -p 8501:8501 \
  -e DATAWRAPPER_ACCESS_TOKEN=your-token-here \
  -e MCP_SERVER_HOST=0.0.0.0 \
  -e MCP_SERVER_PORT=8501 \
  datawrapper-mcp:latest

Environment Variables

  • DATAWRAPPER_ACCESS_TOKEN: Your Datawrapper API token (required)

  • MCP_SERVER_HOST: Server host (default: 0.0.0.0)

  • MCP_SERVER_PORT: Server port (default: 8501)

  • MCP_SERVER_NAME: Server name (default: datawrapper-mcp)

Health Check Endpoint

The HTTP server includes a /healthz endpoint for Kubernetes liveness and readiness probes:

curl http://localhost:8501/healthz
# Returns: {"status": "healthy", "service": "datawrapper-mcp"}

Kubernetes Configuration Example

apiVersion: apps/v1
kind: Deployment
metadata:
  name: datawrapper-mcp
spec:
  replicas: 1
  selector:
    matchLabels:
      app: datawrapper-mcp
  template:
    metadata:
      labels:
        app: datawrapper-mcp
    spec:
      containers:
      - name: datawrapper-mcp
        image: datawrapper-mcp:latest
        ports:
        - containerPort: 8501
        env:
        - name: DATAWRAPPER_ACCESS_TOKEN
          valueFrom:
            secretKeyRef:
              name: datawrapper-secrets
              key: access-token
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8501
          initialDelaySeconds: 5
          periodSeconds: 30
        readinessProbe:
          httpGet:
            path: /healthz
            port: 8501
          initialDelaySeconds: 5
          periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
  name: datawrapper-mcp
spec:
  selector:
    app: datawrapper-mcp
  ports:
  - protocol: TCP
    port: 8501
    targetPort: 8501

Available Tools

8 tools
create_chartA

⚠️ THIS IS THE DATAWRAPPER INTEGRATION ⚠️ Use this MCP tool for ALL Datawrapper chart creation.

DO NOT: ❌ Install the 'datawrapper' Python package ❌ Use the Datawrapper API directly ❌ Import 'from datawrapper import ...' ❌ Run pip install datawrapper

This MCP server IS the complete Datawrapper integration. All Datawrapper operations should use the MCP tools provided by this server.


Create a Datawrapper chart with full control using Pydantic models. This allows you to specify all chart properties including title, description, visualization settings, axes, colors, and more. The chart_config should be a complete Pydantic model dict matching the schema for the chosen chart type.

BEST PRACTICES:

  • Start simple, then add customization based on user feedback

  • Only apply styling when requested or when it significantly improves readability

  • Let Datawrapper handle axis scaling automatically unless there's a specific reason to override

QUICK EXAMPLES:

  1. Basic chart with title: chart_config = { "title": "Monthly Sales", "intro": "Sales data for Q1 2024" }

  2. Chart with custom colors: chart_config = { "title": "Product Comparison", "color_category": { "Product A": "#1f77b4", "Product B": "#ff7f0e" } }

  3. Styled line chart: chart_config = { "title": "Sales Trends", "lines": [ {"column": "sales", "width": "style2", "interpolation": "curved"} ], "custom_range_y": [0, 1000] }

STYLING WORKFLOW:

  1. Use list_chart_types to see available chart types

  2. Use get_chart_schema to explore all options for your chosen type

  3. Refer to https://datawrapper.readthedocs.io/en/latest/ for detailed examples

  4. Build your chart_config with the desired styling properties

Common styling patterns:

  • Colors: {"color_category": {"sales": "#1d81a2", "profit": "#15607a"}}

  • Line styling: {"lines": [{"column": "sales", "width": "style1", "interpolation": "curved"}]}

  • Axis ranges: {"custom_range_y": [0, 100], "custom_range_x": [2020, 2024]} NOTE: Datawrapper's automatic axis scaling is excellent. Only set custom ranges when you need specific customization (e.g., comparing multiple charts, forcing zero baseline for specific analytical reasons, or matching a house style guide).

  • Grid formatting: {"y_grid_format": "0", "x_grid": "on", "y_grid": "on"}

  • Tooltips: {"tooltip_number_format": "00.00", "tooltip_x_format": "YYYY"}

  • Annotations: {"text_annotations": [{"x": "2023", "y": 50, "text": "Peak"}]}

See the documentation for chart-type specific examples and advanced patterns.

Args: data: Chart data. RECOMMENDED: Pass data inline as a list or dict. PREFERRED FORMATS (use these first): 1. List of records (RECOMMENDED): [{"year": 2020, "sales": 100}, {"year": 2021, "sales": 150}] 2. Dict of arrays: {"year": [2020, 2021], "sales": [100, 150]} 3. JSON string of format 1 or 2: '[{"year": 2020, "sales": 100}]' ALTERNATIVE (only for extremely large datasets where inline data is impractical): 4. File path to CSV or JSON: "/path/to/data.csv" or "/path/to/data.json" chart_type: Type of chart to create. Use list_chart_types to see all available types. Common types: bar, line, area, arrow, column, multiple_column, scatter, stacked_bar chart_config: Complete chart configuration as a Pydantic model dict

Returns: Chart ID and editor URL

Inputs: data (required), chart_type (required), chart_config (required). Returns: result

delete_chartA

⚠️ DATAWRAPPER MCP TOOL ⚠️ This is part of the Datawrapper MCP server integration.


Delete a Datawrapper chart permanently.

Args: chart_id: ID of the chart to delete

Returns: Confirmation message

Inputs: chart_id (required). Returns: result

export_chart_pngA

⚠️ DATAWRAPPER MCP TOOL ⚠️ This is part of the Datawrapper MCP server integration.


Export a Datawrapper chart as PNG and display it inline. The chart must be created first using create_chart. Supports high-resolution output via the zoom parameter. IMPORTANT: Only use this tool when the user explicitly requests to see the chart image or export it as PNG. Do not automatically export charts after creation unless specifically asked.

Args: chart_id: ID of the chart to export width: Width of the image in pixels (optional) height: Height of the image in pixels (optional) plain: If true, exports only the visualization without header/footer zoom: Scale multiplier for resolution, e.g., 2 = 2x resolution transparent: If true, exports with transparent background border_width: Margin around visualization in pixels border_color: Color of the border, e.g., '#FFFFFF' (optional)

Returns: PNG image content

Inputs: chart_id (required), width, height, plain, +4 more. Returns: result

get_chartA

⚠️ DATAWRAPPER MCP TOOL ⚠️ This is part of the Datawrapper MCP server integration.


Get information about an existing Datawrapper chart, including its complete configuration, metadata, and URLs.

The returned configuration can be used to:

  • Understand how a chart is styled and configured

  • Adapt the configuration to a new dataset

  • Clone a chart's styling to create similar visualizations

Returns:

  • chart_id: The chart's unique identifier

  • title: Chart title

  • type: Simplified chart type name (bar, line, stacked_bar, etc.) - same format as used in list_chart_types and create_chart

  • config: Complete Pydantic model configuration including all styling, colors, axes, tooltips, annotations, and other properties

  • public_url: Public URL if published

  • edit_url: Editor URL

Args: chart_id: ID of the chart to retrieve

Returns: Chart information including complete configuration and URLs

Inputs: chart_id (required). Returns: result

get_chart_schemaA

⚠️ DATAWRAPPER MCP TOOL ⚠️ This is part of the Datawrapper MCP server integration.


Get the Pydantic JSON schema for a specific chart type. This is your primary tool for discovering styling and configuration options.

The schema shows:

  • All available properties and their types

  • Enum values (e.g., line widths, interpolation methods)

  • Default values

  • Detailed descriptions for each property

WORKFLOW: Use this tool first to explore options, then refer to https://datawrapper.readthedocs.io/en/latest/ for detailed examples and patterns showing how to use these properties in practice.

Args: chart_type: Chart type to get schema for

Returns: JSON schema for the chart type

Inputs: chart_type (required). Returns: result

list_chart_typesA

⚠️ DATAWRAPPER MCP TOOL ⚠️ This is part of the Datawrapper MCP server integration.


List all available Datawrapper chart types with brief descriptions.

Use this tool to discover which chart types you can create. After choosing a type, use get_chart_schema(chart_type) to explore detailed configuration options.

Returns: List of available chart types with descriptions

Inputs: no named parameters. Returns: result

publish_chartA

⚠️ DATAWRAPPER MCP TOOL ⚠️ This is part of the Datawrapper MCP server integration.


Publish a Datawrapper chart to make it publicly accessible. Returns the public URL of the published chart. IMPORTANT: Only use this tool when the user explicitly requests to publish the chart. Do not automatically publish charts after creation unless specifically asked.

Args: chart_id: ID of the chart to publish

Returns: Public URL of the published chart

Inputs: chart_id (required). Returns: result

update_chartA

⚠️ DATAWRAPPER MCP TOOL ⚠️ This is part of the Datawrapper MCP server integration.


Update an existing Datawrapper chart's data or configuration using Pydantic models.

⚠️ IMPORTANT LIMITATION: You CANNOT change the chart type with this tool. Chart types are immutable once created. To change from one chart type to another (e.g., column → stacked_bar, or line → area), you must create a new chart instead.

WHAT YOU CAN UPDATE: • Chart data (add/modify/replace data points) • Title, intro, byline, source information • Colors, styling, axes configuration • Tooltips, annotations, labels • Any other configuration options for the existing chart type

WHAT YOU CANNOT UPDATE: ✗ Chart type (bar, line, column, etc.) - this is permanent

The chart_config must use high-level Pydantic fields only (title, intro, byline, source_name, source_url, etc.). Do NOT use low-level serialized structures like 'metadata', 'visualize', or other internal API fields.

STYLING UPDATES: Use get_chart_schema to see available fields, then apply styling changes:

  • Colors: {"color_category": {"sales": "#ff0000"}}

  • Line properties: {"lines": [{"column": "sales", "width": "style2"}]}

  • Axis settings: {"custom_range_y": [0, 200], "y_grid_format": "0,0"}

  • Tooltips: {"tooltip_number_format": "0.0"}

See https://datawrapper.readthedocs.io/en/latest/ for detailed examples. The provided config will be validated through Pydantic and merged with the existing chart configuration.

Args: chart_id: ID of the chart to update data: New chart data (optional). Same formats as create_chart. chart_config: Updated chart configuration using high-level Pydantic fields (optional)

Returns: Confirmation message with editor URL

Inputs: chart_id (required), data, chart_config. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.3/5.0

    Scored across 8 tools

    Disambiguation5/5

    Each tool has a distinct, well-defined purpose with no overlap. For example, create_chart, get_chart, update_chart, and delete_chart handle different CRUD operations, while list_chart_types, get_chart_schema, publish_chart, and export_chart_png serve unique auxiliary functions. The descriptions clearly differentiate their roles, eliminating any confusion.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern using snake_case, such as create_chart, delete_chart, and export_chart_png. This uniformity makes the set predictable and easy to navigate, with no deviations in naming conventions across the eight tools.

    Tool Count5/5

    With 8 tools, the server is well-scoped for Datawrapper chart management. It covers essential operations like creation, retrieval, updating, deletion, listing, schema exploration, publishing, and exporting, providing a comprehensive yet focused toolset without being overly sparse or bloated.

    Completeness5/5

    The toolset offers complete coverage for the Datawrapper chart domain, including full CRUD operations (create_chart, get_chart, update_chart, delete_chart), lifecycle management (publish_chart), schema discovery (list_chart_types, get_chart_schema), and output handling (export_chart_png). There are no apparent gaps that would hinder an agent's workflow.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      A MCP server for data visualization. It exposes tools to render charts (line, bar, pie, scatter, heatmap, etc.) from data and returns plots as either image/text/mermaid diagram.
      2
      4
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      An MCP server that enables AI assistants to create interactive visualizations, perform statistical analysis, run auto-EDA, and build dashboards using the HoloViz ecosystem with self-contained HTML output.
      36
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      AI-powered data visualization MCP server that generates publication-ready charts from natural language descriptions while keeping data local.
      15 PyPI
      3
      AGPL 3.0