QuickChart Alternatives (2026): Hosted, Self-Hosted and DIY Options Compared
Want to see the output first? Render a chart in the playground. No account needed.
QuickChart is a good tool. It's open source, it renders any Chart.js config, and its site says it has produced over 4 billion images. People still go looking for an alternative, usually for one of five reasons:
- The free tier is rate limited, and the first paid plan is $40 a month for 10,000 images.
- Every chart in a client report needs to match that client's colors, fonts and logo.
- They want a webhook when a batch of charts finishes, not a loop that waits on each request.
- The config is a long URL, and they want a request body.
- They'd rather run it themselves, or not run anything.
This guide covers each option with prices and facts we checked against the vendors' own pricing and documentation pages on November 16, 2026. Where QuickChart is the better choice, it says so.
Which one should you pick?
| If you need... | Pick |
|---|---|
| Scatter, bubble or mixed charts, Chart.js plugins, or JavaScript callbacks | QuickChart, hosted or self-hosted |
| QR codes or barcodes next to your charts | QuickChart |
| One brand kit per client, applied by id | Chart-Output |
| A webhook when a batch of charts is done | Chart-Output |
| An animated GIF, or code already built on Image-Charts | Image-Charts |
| No third party at all, and you already run Node | DIY with node-canvas |
The options side by side
| QuickChart (hosted) | QuickChart (self-hosted) | Image-Charts | Chart-Output | |
|---|---|---|---|---|
| Input | Chart.js config in the URL, or a JSON POST | Same | Google Image Charts parameters, or a Chart.js config in the URL | Chart.js JSON in a POST body |
| Free tier | Community: rate limited, AGPL v3, no watermark | You pay for the server | Unlimited API calls, small watermark | 1,000 renders a month, small watermark |
| First paid plan | $40/mo, 10,000 images, no rate limits | Server and upkeep | $99/mo, or $89/mo billed yearly, unlimited API calls | $19/mo, 25,000 renders |
| Formats | PNG, JPEG, WebP, SVG, PDF, base64 | Same | PNG and GIF documented, WebP on its pricing page | PNG, JPEG, SVG, WebP; PDF on Pro and above |
| Chart.js coverage | Versions 2, 3 and 4, any chart type | Same | Chart.js configs and its own chart types | Chart.js 4: line, bar, pie, doughnut, radar, polar area |
| Brand kits | Custom fonts and backgrounds on Enterprise | Your own code | Custom subdomain, no watermark on Business | Colors, fonts and logo by id: 1 on Free, 3 on Pro, 15 on Agency |
| Async jobs and webhooks | Not in its docs | Your own code | Not in its docs | Every public plan |
On price per thousand renders at the first paid tier, that's about $4.00 for QuickChart Professional and $0.76 for Chart-Output Pro. That comparison only holds if you'd pay for QuickChart at all. If you stay inside its free Community rate limits, QuickChart costs nothing.
QuickChart (hosted)
Best for: any Chart.js chart, plugins, and the widest coverage.
It takes a Chart.js config in the URL or a JSON POST, renders versions 2, 3 and 4, and lists custom plugins on Professional. It also makes QR codes and barcodes. The Community tier is free, AGPL v3, and rate limited. Professional is $40 a month for 10,000 images and 50,000 short URLs, with no rate limits. Enterprise adds custom fonts, custom backgrounds, a custom domain and an on-premise option. For agents it publishes an OpenAPI file, an llms.txt and a validate-chart endpoint, and it lists Google Image Charts compatibility.
Where it can fall short: there is no per-client brand concept in its docs, and we found no async jobs or webhooks in them.
QuickChart (self-hosted)
Best for: teams that want no per-render bill and are fine running the server.
The QuickChart server is open source, so you can run the same renderer yourself. The cost moves from a plan to your own servers, security patching and scaling. It's licensed under AGPL v3, so read the license against how you ship software.
Image-Charts
Best for: teams already on Image-Charts, and animated GIFs.
Its classic API describes a chart in URL parameters (cht, chd, chl), and it also accepts a Chart.js config in the URL. The Free tier has unlimited API calls with a small watermark. Business removes the watermark and adds a custom subdomain and Zapier and Make integration, at $99 a month or $89 billed yearly. Enterprise is $249 a month, or $224 billed yearly. It documents animated GIF output, which QuickChart and Chart-Output don't offer.
Chart-Output
Best for: recurring reports where every chart has to match a brand, and pipelines that need a webhook.
You POST Chart.js JSON and get back a PNG, JPEG, SVG, WebP or PDF. A brand kit holds a palette, fonts and a logo, and you apply it with a brandKitId, so one integration can serve many clients.
curl -X POST https://www.chart-output.com/api/v1/render \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"type": "bar",
"width": 800,
"height": 400,
"format": "png",
"data": {
"labels": ["Jan", "Feb", "Mar", "Apr", "May", "Jun"],
"datasets": [{
"label": "MRR",
"data": [4200, 4800, 5100, 5600, 6200, 7100],
"backgroundColor": "rgba(99, 102, 241, 0.8)"
}]
}
}' \
--output chart.png- Invalid chart configs return JSON listing each failing field path and the reason, so LLM and agent callers can correct the request and retry.
- Async jobs return a job id and send a signed
render.completewebhook, or you can poll the job.
Pricing: Free is 1,000 renders a month with a small watermark, no card. Pro is $19 a month for 25,000 renders, with PDF, 3 brand kits and no watermark. Agency is $79 a month for 150,000 renders and 15 brand kits.
Where it falls short: it renders six chart types (line, bar, pie, doughnut, radar, polar area). Scatter, bubble and mixed charts are not supported, and neither are options that need JavaScript callbacks, because the spec is JSON. It is not open source and can't be self-hosted.
DIY: node-canvas or headless Chromium
Best for: teams that don't want a vendor and already operate Node services.
node-canvas needs native Cairo bindings, which are easy on a Linux server and painful in serverless functions. Puppeteer runs a full Chromium to screenshot a page, which means managing browser pools, memory and version drift. We wrote the trade-offs up in chartjs-node-canvas vs Puppeteer. The hidden cost is that you now maintain a chart renderer instead of your product.
Migrating from QuickChart: the checklist
If your charts are bar, line, pie, doughnut, radar or polar area, the move is mostly the request. These are the places it isn't:
| QuickChart | Chart-Output |
|---|---|
GET /chart?c=<config> | POST /api/v1/render with a JSON body and Authorization: Bearer |
Chart.js version 2 by default; set version for 3 or 4 | Chart.js 4. Rewrite version 2 axes (scales: { yAxes: [...] }) as scales: { y: {...} } |
| Pixel ratio 2 by default | devicePixelRatio defaults to 1. Send devicePixelRatio: 2 for the same sharpness, within your plan's pixel limit (1,200 px Free, 3,000 px paid) |
| Default size 500 by 300 | width and height default to 800 by 400. Send width: 500, height: 300 to match |
| Scatter, bubble, mixed types, plugins, callbacks | Not supported. Keep those charts on QuickChart |
The request itself:
const url = `https://quickchart.io/chart?c=${encodeURIComponent(JSON.stringify(chartConfig))}`;
const response = await fetch(url);
const imageBuffer = Buffer.from(await response.arrayBuffer());Sign up at chart-output.com (the free tier needs no card), copy your key from API Keys, and run one of your real configs through both before you decide. The response is the image bytes, so it drops into the same storage, email or PDF step.
A complete example: monthly report chart
const fs = require('fs');
async function generateMonthlyChart(data) {
const response = await fetch('https://www.chart-output.com/api/v1/render', {
method: 'POST',
headers: {
Authorization: `Bearer ${process.env.CHART_OUTPUT_API_KEY}`,
'Content-Type': 'application/json',
},
body: JSON.stringify({
type: 'line',
width: 900,
height: 450,
format: 'png',
data: {
labels: data.months,
datasets: [{
label: 'Revenue',
data: data.revenue,
borderColor: '#6366f1',
backgroundColor: 'rgba(99, 102, 241, 0.1)',
tension: 0.4,
}],
},
options: {
plugins: { legend: { position: 'top' } },
scales: { y: { beginAtZero: true } },
},
}),
});
if (!response.ok) {
const error = await response.json();
throw new Error(`Chart render failed: ${error.error}`);
}
fs.writeFileSync('./report-chart.png', Buffer.from(await response.arrayBuffer()));
console.log('Chart saved to report-chart.png');
}
generateMonthlyChart({
months: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun'],
revenue: [42000, 48000, 51000, 56000, 62000, 71000],
});Put the chart where people read it
A rendered chart is only useful once it lands somewhere. These guides cover the common destinations:
- Add a chart to an n8n workflow with the HTTP Request node
- Add a chart in Zapier or Make
- Chart.js in email
- Chart.js in PDF reports
- Charts for Slack, Discord and Teams
To see what a finished chart looks like, open the gallery. Every chart there shows the exact request that produced it.
FAQ
How much does QuickChart cost in 2026?
As of November 16, 2026, QuickChart's Community tier is free, open source under the GNU AGPL v3, and rate limited. Its Professional plan is $40 a month for 10,000 images a month, with no rate limits and commercial use. Enterprise is priced by contacting them.
Does QuickChart support PDF and WebP?
Yes. QuickChart's API documentation lists png, jpg, webp, svg, pdf and base64 as values for the format parameter. Chart-Output also renders PNG, JPEG, SVG and WebP on every plan, with PDF on Pro and above.
What are the best QuickChart alternatives for Chart.js image rendering?
The main options are Chart-Output (hosted, Chart.js JSON in a POST body, brand kits, async jobs with webhooks), Image-Charts (hosted, URL parameters plus Chart.js configs in the URL, animated GIF), self-hosting the open-source QuickChart server, and rendering Chart.js yourself with node-canvas or headless Chromium. Which fits depends on whether you need scatter and bubble charts, brand kits, webhooks, or full control of the infrastructure.
How do I migrate from QuickChart to another chart image API without rewriting my charts?
For bar, line, pie, doughnut, radar and polar area charts, the migration is mostly the request. Change GET to POST, put the config in a JSON body, add an Authorization header, and check three defaults. QuickChart renders Chart.js version 2 unless you set a version, and uses a pixel ratio of 2, while Chart-Output renders Chart.js 4 at a pixel ratio of 1. Scatter and bubble charts, plugins and JavaScript callbacks do not carry over.
Is there a chart image API that works in serverless functions (Vercel, AWS Lambda, Netlify)?
Yes. Any hosted chart image API works in serverless environments because there are no native dependencies to install; you make an HTTP request. Chart-Output, QuickChart's hosted service and Image-Charts all work this way. Running node-canvas or Puppeteer inside a serverless function is possible but needs significant build configuration and adds a large bundle.
Try it on your own chart
Chart-Output's free tier is 1,000 renders a month with no credit card. Paste one of your own configs into the request above and see the image in a few minutes.