Datawrapper MCP
Click on "Deploy 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., "@Datawrapper MCP Create a line chart showing 2023 sales data and publish it"
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.
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
A Datawrapper account (sign up at https://datawrapper.de/signup/)
An MCP client such as Claude or OpenAI Codex
Python 3.10 or higher
Get Your API Token
Create a new API token
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-mcpThen 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-mcpThen 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:
Under Custom servers, click
Add serverUnder Name, enter
datawrapper-mcpSelect STDIO
Under Command to launch, type
uvx(you must have uv installed)Under Arguments, add
datawrapper-mcpUnder Environment variables, add
DATAWRAPPER_ACCESS_TOKENas the key and your token as the valueClick 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:latestEnvironment 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: 8501Available Tools
8 toolscreate_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:
Basic chart with title: chart_config = { "title": "Monthly Sales", "intro": "Sales data for Q1 2024" }
Chart with custom colors: chart_config = { "title": "Product Comparison", "color_category": { "Product A": "#1f77b4", "Product B": "#ff7f0e" } }
Styled line chart: chart_config = { "title": "Sales Trends", "lines": [ {"column": "sales", "width": "style2", "interpolation": "curved"} ], "custom_range_y": [0, 1000] }
STYLING WORKFLOW:
Use list_chart_types to see available chart types
Use get_chart_schema to explore all options for your chosen type
Refer to https://datawrapper.readthedocs.io/en/latest/ for detailed examples
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
Scored across 8 tools
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.
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.
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.
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
Related MCP Connectors
MCP server that lets your AI assistant build and deploy apps, hosting each one at a live URL.
An MCP server that integrates with Discord to provide AI-powered features.
MCP server that lets AI assistants use all OneSchema features exposed via the public API.
One MCP server for the services your AI needs: memory, files, Microsoft 365, kanban and more.
Related MCP Servers
- AlicenseAqualityDmaintenanceA 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.24MIT
- AlicenseAqualityDmaintenanceAn 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.36MIT
- AlicenseNot gradedqualityCmaintenanceAI-powered data visualization MCP server that generates publication-ready charts from natural language descriptions while keeping data local.15 PyPI3AGPL 3.0

image-charts-mcpofficial
AlicenseAqualityDmaintenanceAn MCP server that turns chart requests into permanent, hosted Image-Charts URLs, enabling agents to generate charts that render anywhere without client-side libraries.34 npmMIT