QuickChart

Overview

QuickChart provides an API for generating static chart images and QR codes. It enables developers to render various chart types server-side, primarily based on the Chart.js library, without requiring a browser or client-side JavaScript execution. This functionality is suited for scenarios where dynamic client-side rendering is not feasible or desired, such as embedding charts in emails, generating reports, creating PDFs, or integrating data visualizations into systems that do not support interactive JavaScript.

The service targets developers and technical teams who need to automate the creation of visual data representations. It supports common chart types including bar, line, pie, and scatter charts, configured via a JSON payload sent to the API. This approach allows for consistent chart rendering across different environments and ensures that charts are accessible even in contexts with limited scripting capabilities. QuickChart also offers specific endpoints for generating QR codes, which can optionally encode chart data or links.

QuickChart's design emphasizes ease of integration through its RESTful API. It provides official SDKs across multiple programming languages, including Node.js, Python, Ruby, PHP, Java, Go, and C#, to streamline development. The API handles the rendering process on its servers, delivering a PNG or SVG image of the chart. This server-side rendering ensures that charts are always displayed correctly, regardless of the end-user's device or email client. The service is particularly beneficial for backend applications that need to produce visual output without managing browser environments or client-side rendering libraries.

The platform maintains a focus on generating images from standard Chart.js configurations, which allows developers familiar with Chart.js to translate their existing chart definitions directly into API requests. This reduces the learning curve and permits a wide range of customization options for chart appearance and data presentation. For example, a developer can define datasets, labels, colors, and scales using standard Chart.js options, and QuickChart will process these into a visual output. The service also supports various image sizes and quality settings to accommodate different display requirements.

Beyond charts, QuickChart's capability to generate QR codes extends its utility for embedding links or short data strings into visual formats. This feature can be used in conjunction with charts, for instance, by linking to an interactive version of a chart, or independently for other application needs. The platform's documentation offers comprehensive guides and examples for integrating these features into diverse applications, making it accessible for developers regardless of their specific tech stack.

Key features

• Chart Image API: Generates static chart images (PNG, SVG) from Chart.js configurations. This allows for server-side rendering of various chart types, including line, bar, pie, and scatter charts, useful for embedding in contexts that do not support client-side JavaScript rendering, such as emails or PDF reports.
• Chart QR Code Generation: Creates QR codes that can encode URLs, text, or even a link to a rendered chart image. This feature supports various error correction levels and custom sizing for integration into digital and print media.
• Extensive Chart.js Support: Utilizes the Chart.js library for chart definitions, allowing developers to use familiar JSON configurations to specify chart data, appearance, and options.
• Multiple SDKs: Provides client libraries for Node.js, Python, Ruby, PHP, Java, Go, and C#, simplifying API integration into applications built with these languages.
• Server-side Rendering: Offloads the chart rendering process to QuickChart's servers, eliminating the need for client-side dependencies or headless browser setups in the developer's infrastructure.
• Customizable Chart Styling: Supports detailed customization of chart elements such as colors, fonts, labels, axes, and tooltips through the Chart.js configuration options.
• GDPR Compliance: Adheres to General Data Protection Regulation (GDPR) standards, providing assurances concerning data privacy and handling.

Pricing

QuickChart offers a free tier for initial usage, with paid plans based on request volume. Pricing is current as of May 2026.

For detailed and up-to-date pricing information, refer to the QuickChart pricing page.

Common integrations

• Email Platforms: Embed static charts directly into email campaigns or transactional emails that often have limited JavaScript execution capabilities.
• Reporting Tools: Integrate charts into automated report generation systems for business intelligence, financial summaries, or operational dashboards.
• PDF Generation Services: Use QuickChart to render charts for inclusion in dynamically generated PDF documents, such as invoices, statements, or permits.
• Workflow Automation Platforms: Connect with tools like Zapier or Tray.io to automate chart creation as part of broader data processing or communication workflows. For example, Tray.io offers a QuickChart connector.
• Backend Applications: Server-side rendering for web applications, mobile app backends, or any system where charts need to be generated without client-side browser environments.
• Databases and Data Warehouses: Visualize data retrieved directly from databases by passing query results to QuickChart for image generation.

Alternatives

• Chart.js: A JavaScript charting library for client-side rendering, primarily used in web browsers. QuickChart uses Chart.js configurations but renders server-side.
• Google Charts: A web service that creates interactive charts, relying on client-side JavaScript.
• Highcharts: A commercial JavaScript charting library for interactive client-side charts, offering a wide range of chart types and customization.
• Apache ECharts: An open-source JavaScript visualization library that provides various interactive chart types, similar to Highcharts and Google Charts in its client-side focus.
• Nivo: A React-specific charting library that simplifies the creation of data visualizations using D3.js and React components.

Getting started

To generate a simple bar chart using QuickChart with Python, you can use the official Python SDK. This example defines a basic bar chart configuration and generates a URL for the chart image.

import quickchart

# Initialize QuickChart client
qc = quickchart.QuickChart()

# Define chart configuration using Chart.js syntax
qc.config = {
    "type": "bar",
    "data": {
        "labels": ["January", "February", "March", "April", "May"],
        "datasets": [{
            "label": "Monthly Sales",
            "data": [12, 19, 3, 5, 2],
            "backgroundColor": "rgba(75, 192, 192, 0.6)"
        }]
    }
}

# Set chart width and height
qc.width = 500
qc.height = 300

# Get the chart URL
chart_url = qc.get_url()
print(f"Chart URL: {chart_url}")

# Alternatively, save the chart as a file
# qc.to_file('my_chart.png')
# print("Chart saved to my_chart.png")

This Python code snippet first imports the quickchart library. It then creates an instance of quickchart.QuickChart and assigns a Chart.js configuration to its config property. The configuration specifies a bar chart with labels and a single dataset. After setting the desired dimensions, qc.get_url() is called to retrieve a URL that can be used to display the generated chart image in a web browser or embed it in other applications. More examples and detailed instructions for other languages are available in the QuickChart documentation.