Secciones de la documentación

Autenticación

Cada llamada a una calculadora lleva una clave de API, en todos los planes; una clave gratuita no cuesta nada. Las rutas de las calculadoras, las de los trabajos y el endpoint de uso la aceptan en cualquiera de las dos cabeceras.

Las claves empiezan por rfc_. Una clave se muestra una vez, al crearla, y nunca más: solo se guarda su hash.

Enviar la clave

Envíe la clave en la cabecera X-API-Key o como Authorization: Bearer rfc_…. Una solicitud sin clave se rechaza con 401 y una keyUrl; una clave que nunca se emitió, o que se revocó, también se rechaza con 401. Un 401 nunca se refiere a la cuota: una cuota agotada es 402 (consulte Errores).

La cuota pertenece a la cuenta

Las llamadas de todas las claves de una cuenta, incluidas las revocadas, se descuentan de una única cifra mensual; se restablece al inicio de cada mes natural en UTC, y cada llamada se sigue atribuyendo a la clave que la hizo.

Cuota mensual y límite de claves por plan
Plan	Llamadas al mes y claves
Free	5 llamadas al mes, 1 clave de API
Pro	100 llamadas al mes, 3 claves de API
API	10.000 llamadas al mes, 5 claves de API

Obtener una clave

Una persona la obtiene en el panel. Un programa tiene dos formas de dar una a su usuario, y ambas producen una clave rfc_ normal, contabilizada, listada y revocable como cualquier otra.

Un enlace de clave

Abra https://rftools.io/dashboard/?newKey=1&client=<clientId>[&label=<text>] en el navegador del usuario. clientId nombra el programa y cumple ^[a-z0-9][a-z0-9-]{1,39}$, por ejemplo kicad-plugin; un valor que no lo cumple se ignora, no se rechaza. Un usuario sin sesión inicia sesión o se registra y vuelve al mismo enlace. El panel abre su diálogo de creación de claves con la etiqueta rellenada (<clientId> — <date> salvo que el enlace indique otra) y muestra la clave una vez para que el usuario la pegue en el programa.

El diálogo llama a POST /api/py/v1/apikeys, que una sesión iniciada puede llamar directamente; el cuerpo es opcional. Una cuenta que ha alcanzado su límite de claves se rechaza con 400 y se le pide que revoque antes una clave.

Obtener una clave de API gratuita

La autorización de dispositivo, para un programa sin navegador

La autorización de dispositivo de OAuth 2.0 (device authorization grant, RFC 8628) da una clave a un programa (un complemento, una CLI, un servidor MCP local) sin que el usuario pegue nada. El programa pide un código, muestra al usuario el código y https://rftools.io/device/, y consulta periódicamente. El usuario inicia sesión allí, ve el nombre que el programa se dio a sí mismo y aprueba o deniega. Tras la aprobación, la siguiente consulta del programa devuelve la clave, una sola vez. Ambos endpoints aceptan JSON o un cuerpo de formulario.

Un código tiene 8 letras de BCDFGHJKLMNPQRSTVWXZ, se muestra como XXXX-XXXX y caduca 10 minutos después de emitirse.
No consulte más rápido que interval (5 s al principio).
La clave cuenta para el límite de claves de la cuenta; a una cuenta que ha alcanzado su límite se le pide que revoque antes una clave.
Muestre al usuario solo el código. El device_code es el secreto del programa hasta que se canjea.
La biblioteca de Python hace todo esto: rftools login o rftools.Client().login().

Mientras espera, el endpoint de token responde 400 con un error de RFC 8628:

Errores de la autorización de dispositivo
error	Qué significa
authorization_pending	El usuario todavía no ha decidido. Siga consultando con el intervalo.
slow_down	Se consultó más rápido que el intervalo. El intervalo aumenta 5 s; el cuerpo lleva el nuevo intervalo.
access_denied	El usuario denegó el código, o la cuenta alcanzó su límite de claves antes de recoger la clave. Deje de consultar.
expired_token	El código caducó (10 minutos después de emitirse) o su clave ya se recogió. Empiece de nuevo.
invalid_grant	El código de dispositivo se emitió para otro client_id.
invalid_request / unsupported_grant_type	Falta un parámetro o el grant_type es incorrecto.

Los endpoints de la autorización de dispositivo se someten al límite de frecuencia sin credencial, lleven lo que lleven.

Cualquiera de las dos cabeceras

X-API-Key: rfc_a1b2c3d4e5f6…
# or
Authorization: Bearer rfc_a1b2c3d4e5f6…

Crear una clave desde una sesión iniciada

curl -X POST https://rftools.io/api/py/v1/apikeys \
  -H "Authorization: Bearer $SESSION_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "label": "Bench PC",
    "client": "kicad-plugin"
  }'

import os

import httpx

response = httpx.post(
    "https://rftools.io/api/py/v1/apikeys",
    headers={"Authorization": f"Bearer {os.environ['SESSION_TOKEN']}"},
    json={"label": "Bench PC", "client": "kicad-plugin"},
)
print(response.status_code, response.json())

const response = await fetch("https://rftools.io/api/py/v1/apikeys", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.SESSION_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "label": "Bench PC",
    "client": "kicad-plugin"
  }),
});
console.log(response.status, await response.json());

package main

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{
	  "label": "Bench PC",
	  "client": "kicad-plugin"
	}`)
	req, err := http.NewRequest("POST", "https://rftools.io/api/py/v1/apikeys", bytes.NewReader(body))
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("SESSION_TOKEN"))
	req.Header.Set("Content-Type", "application/json")
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

200application/json

{
  "key": "rfc_…",
  "key_id": "rfc_…",
  "created_at": 1758722711,
  "label": "Bench PC",
  "client": "kicad-plugin",
  "monthly_quota": 5
}

La clave aparece en esta respuesta una sola vez y nunca más.

La autorización de dispositivo

Autorización de dispositivo

# 1. the program asks for a code
curl -X POST https://rftools.io/api/py/v1/oauth/device/code \
  -H "Content-Type: application/json" \
  -d '{"client_id":"kicad-plugin"}'
# → {"device_code":"…","user_code":"BCDF-GHJK",
#    "verification_uri":"https://rftools.io/device/",
#    "verification_uri_complete":"https://rftools.io/device/?user_code=BCDF-GHJK",
#    "expires_in":600,"interval":5}

# 2. it shows the user the code and the address, then polls every interval seconds
curl -X POST https://rftools.io/api/py/v1/oauth/device/token \
  -H "Content-Type: application/json" \
  -d '{"grant_type":"urn:ietf:params:oauth:grant-type:device_code",
       "device_code":"…","client_id":"kicad-plugin"}'
# → 400 {"error":"authorization_pending", …}   until the user decides
# → 200 {"access_token":"rfc_…","token_type":"Bearer","key_id":"rfc_…",
#        "label":"kicad-plugin — 2026-09-24","client":"kicad-plugin","monthly_quota":5}