JSON a gráfico

JSON a gráfico es una API que convierte datos en una imagen de gráfico (barras, líneas, tarta, donut o radar). Le mandas tus números en JSON y te devuelve una imagen lista para meter en un email, un informe o un mensaje de Slack, sin diseñar nada a mano.

Cómo funciona

Le mandas el tipo de gráfico, las etiquetas (categorías del eje X, o nombres de cada porción) y una o varias series de números, y te devuelve la imagen ya generada: por defecto en PNG, dentro de una respuesta JSON en base64.

Como la entrada siempre es una estructura de datos, esta herramienta solo admite el cuerpo en JSON (no hay modo "pega el archivo a pelo").

Lo único que necesitas

Tu API key. La creas en tu panel con "+ Crear llave". Se muestra una sola vez, así que cópiala y guárdala.
En tu plataforma de automatización, un paso de tipo "HTTP Request" / "Hacer una petición HTTP" (lo tienen n8n, Make, Zapier, Pipedream…).
Tus datos como números: el resto lo hace la herramienta.

Cómo usarlo en n8n (paso a paso)

En el nodo HTTP Request:

Method: POST
URL: https://api.cofferdock.com/chart
Send Headers: actívalo y añade dos: x-api-key = tu llave, y Content-Type = application/json
Send Body: actívalo → Body Content Type: JSON → { "type": "bar", "labels": ["Ene", "Feb", "Mar"], "series": [{ "name": "Ventas", "data": [10, 20, 15] }] }

Por defecto la respuesta ya es un JSON con la imagen en base64 dentro del campo image, así que no hace falta tocar nada más en Options → Response. Si prefieres recibir la imagen directamente (para adjuntarla como binario), añade "output": "binary" al cuerpo y elige Response Format: File en Options → Response, igual que en otras herramientas de Cofferdock.

En Make (módulo HTTP → Make a request): mismo método y URL, Body type: Raw, Content type: JSON, con el mismo cuerpo.

Opciones (dentro del JSON)

Opción	Por defecto	Para qué sirve
`type`	-	Obligatorio. Tipo de gráfico: `bar`, `line`, `pie`, `doughnut` o `radar`.
`labels`	-	Obligatorio. De 1 a 50 textos: categorías del eje X (barras/líneas) o nombre de cada porción/indicador (tarta/radar).
`series`	-	Obligatorio. De 1 a 10 series, cada una `{ "name": "...", "data": [...] }` con tantos números como `labels`. `pie`/`doughnut` solo admiten 1 serie.
`title`	-	Título del gráfico (opcional).
`width` / `height`	800 / 500	Tamaño en píxeles (entre 200 y 2000).
`format`	`png`	`png` o `svg`.
`output`	`json`	`json` (imagen en base64 dentro de un JSON) o `binary` (la imagen directamente).

Resumen de la API

Endpoint: POST https://api.cofferdock.com/chart
Auth: cabecera x-api-key: TU_LLAVE.
Entrada: SOLO application/json.
Salida: por defecto JSON con la imagen en base64; con "output": "binary" devuelve la imagen directamente (image/png o image/svg+xml según format).
Motor: Apache ECharts en modo servidor (sin navegador ni canvas), rasterizado a PNG con sharp cuando hace falta.
Límites: 30 peticiones/min por IP. 1 gráfico = 1 crédito, sin importar el tipo o el tamaño.

Opciones

Opción	Por defecto	Descripción
`type`	-	Obligatorio. `bar \| line \| pie \| doughnut \| radar` (400 si no está en la lista).
`labels`	-	Obligatorio. Array de 1 a 50 strings no vacíos, hasta 100 caracteres cada uno.
`series`	-	Obligatorio. Array de 1 a 10 objetos `{ name?, data }`. `data` debe tener el mismo largo que `labels` y contener solo números finitos. `name` es opcional (hasta 100 caracteres; si falta, se usa `"Series N"`). `pie`/`doughnut`: 400 si `series.length > 1`.
`title`	-	String opcional, hasta 200 caracteres.
`width` / `height`	800 / 500	Número, se ajusta automáticamente al rango [200, 2000].
`format`	`png`	`png` o `svg`.
`output`	`json`	`json` o `binary`.

Ejemplos

curl (gráfico de barras directo a PNG):

curl -X POST "https://api.cofferdock.com/chart" \
  -H "x-api-key: TU_LLAVE" \
  -H "Content-Type: application/json" \
  -d '{"type":"bar","labels":["Ene","Feb","Mar"],"series":[{"name":"Ventas","data":[10,20,15]}],"output":"binary"}' \
  -o grafico.png

JavaScript (Node 18+):

const r = await fetch('https://api.cofferdock.com/chart', {
  method: 'POST',
  headers: { 'x-api-key': 'TU_LLAVE', 'Content-Type': 'application/json' },
  body: JSON.stringify({
    type: 'pie',
    title: 'Reparto',
    labels: ['A', 'B', 'C'],
    series: [{ data: [40, 25, 35] }],
  }),
});
const { image } = await r.json();
require('fs').writeFileSync('grafico.png', Buffer.from(image, 'base64'));

Python:

import base64, requests
r = requests.post(
    'https://api.cofferdock.com/chart',
    headers={'x-api-key': 'TU_LLAVE', 'Content-Type': 'application/json'},
    json={'type': 'line', 'labels': ['Ene', 'Feb', 'Mar'], 'series': [{'data': [10, 20, 15]}], 'output': 'binary'},
)
open('grafico.png', 'wb').write(r.content)

Respuesta con `output=json` (por defecto)

{ "success": true, "image": "iVBORw0KGgoAAAANSUhEUgAA…", "mime_type": "image/png",
    "meta": { "format": "png", "width": 800, "height": 500, "used": 12, "remaining": 488 } }

Lo que recibes

Por defecto, un JSON con la imagen en base64: cómodo para usarla directo en el siguiente paso de tu flujo (por ejemplo, incrustarla en un email como data:image/png;base64,…) sin pasos extra. Con "output": "binary" recibes la imagen directamente, útil si el siguiente paso espera un archivo binario.