# Documentación para desarrolladores Publica y sincroniza los eventos de tu empresa en Remolom desde tu web, tu sistema de reservas, tu ticketing o un asistente de IA, y entérate al momento de cada venta y cada entrada validada. Todo lo que entra por la API pasa por las mismas validaciones y la misma moderación que los eventos creados en la web. Remolom sirve para cualquier tipo de evento: conciertos, teatro, museos, gastronomía, ferias, stand-up, fiestas y deporte. ## Qué puedes hacer - [Inicio rápido](https://remolom.com/developers/quickstart): crea una clave y publica tu primer evento en 5 minutos. - [Autenticación](https://remolom.com/developers/authentication): claves `rk_live_` y `rk_test_`, permisos y OAuth con PKCE para plataformas. - [Eventos](https://remolom.com/developers/events): campos, upsert por `externalId`, pósters, `ticketUrl`, zonas horarias y categorías. - [Sedes](https://remolom.com/developers/branches) y [Entradas y estadísticas](https://remolom.com/developers/tickets). - [Webhooks](https://remolom.com/developers/webhooks): avisos firmados de eventos y entradas, con reintentos. - [Sincronización de feeds](https://remolom.com/developers/feeds): tu agenda (iCal, CSV o web) se mantiene sola. - [MCP](https://remolom.com/developers/mcp) y [Úsalo con IA](https://remolom.com/developers/ai): Claude Code, Claude Desktop, `llms.txt` y una skill lista para instalar. - [Errores y límites](https://remolom.com/developers/errors) y [Changelog](https://remolom.com/developers/changelog). ## Datos básicos - Base de la API: `https://remolom.com/api/v1`. JSON en la petición y en la respuesta. - Autenticación: `Authorization: Bearer `. - Errores: siempre `{ "error": "mensaje" }` con un código HTTP estable. - Importes en la unidad menor de la moneda: EUR `1850` = 18,50 €; COP `15000` = 15.000 $. ## OpenAPI El esquema OpenAPI 3.1 de `/v1` está en [/api/v1/openapi.json](https://remolom.com/api/v1/openapi.json). Impórtalo en Postman o Insomnia para tener todas las rutas listas, o genera un SDK con tu herramienta favorita (por ejemplo `openapi-generator`). --- # Inicio rápido En 5 minutos: crea una clave de prueba y publica tu primer evento con una sola petición idempotente. ## 1. Crea una clave 1. Entra en [Mi empresa → Integraciones](https://remolom.com/dashboard/company?tab=integrations). Tienes que ser owner o admin de la empresa. 2. Pon un nombre, marca **Puede crear, editar y cancelar eventos** y elige el modo **Prueba**. 3. Copia la clave `rk_test_…`. Se muestra **una sola vez**: guárdala como un secreto, en tu servidor, nunca en el navegador. Lo que crea una clave de prueba no es público y se borra a los 7 días. Cuando todo funcione, crea una clave **Real** (`rk_live_…`) y repite. ```bash export REMOLOM_KEY=rk_test_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ``` ## 2. Publica un evento (upsert) `PUT /v1/events/external/:source/:externalId` crea el evento si no existe (201) y lo actualiza si ya existe (200). Usa el id del evento en tu sistema como `externalId`: puedes repetir la petición sin crear duplicados. ```bash curl -X PUT https://remolom.com/api/v1/events/external/mi-web/jazz-2026-12-05 \ -H "Authorization: Bearer $REMOLOM_KEY" \ -H "Content-Type: application/json" \ -d '{ "title": "Concierto de jazz", "categories": ["musica"], "startsAt": "2026-12-05T21:00", "venueName": "Sala Clamores", "address": "Calle Alburquerque 14, Madrid", "isFree": false, "prices": [{ "name": "General", "priceCents": 1850 }], "currency": "EUR", "ticketUrl": "https://mi-web.com/entradas/jazz" }' ``` ```js // Node 18+ (fetch nativo) const res = await fetch('https://remolom.com/api/v1/events/external/mi-web/jazz-2026-12-05', { method: 'PUT', headers: { Authorization: `Bearer ${process.env.REMOLOM_KEY}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ title: 'Concierto de jazz', categories: ['musica'], startsAt: '2026-12-05T21:00', venueName: 'Sala Clamores', address: 'Calle Alburquerque 14, Madrid', isFree: false, prices: [{ name: 'General', priceCents: 1850 }], currency: 'EUR', }), }) const { event, error } = await res.json() console.log(res.status, event?.id ?? error) // 201 la primera vez, 200 después ``` ```python import os, requests r = requests.put( "https://remolom.com/api/v1/events/external/mi-web/jazz-2026-12-05", headers={"Authorization": f"Bearer {os.environ['REMOLOM_KEY']}"}, json={ "title": "Concierto de jazz", "categories": ["musica"], "startsAt": "2026-12-05T21:00", "venueName": "Sala Clamores", "address": "Calle Alburquerque 14, Madrid", "isFree": False, "prices": [{"name": "General", "priceCents": 1850}], "currency": "EUR", }, ) print(r.status_code, r.json()) ``` La respuesta es `{ "event": EventDTO }` con el `id` de Remolom, las fechas en UTC y `"test": true` si usaste una clave de prueba. ## 3. Comprueba y cancela ```bash curl https://remolom.com/api/v1/events -H "Authorization: Bearer $REMOLOM_KEY" curl -X DELETE https://remolom.com/api/v1/events/external/mi-web/jazz-2026-12-05 \ -H "Authorization: Bearer $REMOLOM_KEY" ``` `DELETE` cancela el evento, no lo borra. Un `PUT` posterior con el mismo `externalId` lo reactiva. ## Siguientes pasos - Revisa qué campos son obligatorios en [Eventos](https://remolom.com/developers/events). - Recibe avisos de ventas con [Webhooks](https://remolom.com/developers/webhooks). - ¿Tu agenda ya está en iCal o CSV? Mira [Sincronización de feeds](https://remolom.com/developers/feeds): no hace falta programar. --- # Autenticación Claves de API para tu propia empresa y OAuth con PKCE para plataformas que publican en nombre de muchas empresas. Todas las peticiones a `/v1` y al MCP llevan la cabecera `Authorization: Bearer `. Puede ser una clave de API (`rk_live_…`, `rk_test_…`) o un access token de OAuth (`ro_at_…`): funcionan igual. ## Claves de API Se crean en [Mi empresa → Integraciones](https://remolom.com/dashboard/company?tab=integrations) (owner o admin). La clave se muestra una sola vez; Remolom solo guarda su hash. - **Real** (`rk_live_…`): publica eventos reales, visibles para todo el mundo. - **Prueba** (`rk_test_…`): lo que crea lleva `"test": true`, no sale en búsquedas, mapa ni perfiles y se borra a los 7 días. Una clave de prueba solo ve sus eventos de prueba, y una real solo los reales; el resto da 404. - La clave actúa en nombre de quien la creó. Si esa persona deja de ser owner o admin, o se suspende su cuenta, la clave deja de valer (401). - Puedes revocarla cuando quieras desde el mismo panel. - Máximo de claves activas: 2 en el plan gratis y 10 con Remolom PRO. ```bash curl https://remolom.com/api/v1/branches -H "Authorization: Bearer rk_test_…" ``` ## Permisos (scopes) | Scope | Permite | |---|---| | `events:read` | Leer eventos y sedes (`GET /v1/events`, `GET /v1/branches`) | | `events:write` | Crear, editar, hacer upsert, cancelar eventos y subir pósters | | `tickets:read` | Ver entradas, compradores y estadísticas de venta | | `webhooks:manage` | Gestionar webhooks por API (`/v1/webhooks`) | En el panel, toda clave lleva `events:read`; las casillas añaden `events:write` y `tickets:read`. Los webhooks se gestionan desde el panel, o por API con una app OAuth que pida `webhooks:manage`. Sin el scope necesario la respuesta es 403. ## OAuth para plataformas Si tu software (ticketing, CMS, agenda cultural…) publica en nombre de muchas empresas, no pidas claves: registra una app OAuth y deja que cada empresa te dé permiso con un clic. Flujo **authorization code con PKCE** (`S256` obligatorio). Cada empresa puede revocar el acceso cuando quiera. ### 1. Registra la app En [Mis apps OAuth](https://remolom.com/developers/apps) crea la app con nombre, web (https), logo opcional y las `redirect_uri` exactas (https, o `http://localhost` / `127.0.0.1` para desarrollo; de 1 a 10). Recibes: - `client_id` (`ro_ci_…`): público. - `client_secret` (`ro_cs_…`): se ve **una sola vez**. Guárdalo en tu servidor. La app nace **pendiente**: hasta que Remolom la apruebe solo puede conectarse a empresas donde tú eres owner o admin. Perfecto para probar. Las mismas rutas de la página (con tu sesión de Remolom): | Ruta | Para qué | |---|---| | `GET /api/oauth/clients` | Tus apps (`{ clients }`) | | `POST /api/oauth/clients` | Crear `{ name, website, logoUrl?, redirectUris }` → `{ client, clientSecret }` | | `PATCH /api/oauth/clients/:id` | Editar nombre, web, logo o `redirectUris` (solo lo que mandes) → `{ client }` | | `POST /api/oauth/clients/:id/rotate-secret` | Nuevo `client_secret`, visible una vez → `{ client, clientSecret }`. El anterior deja de valer al momento; los tokens ya emitidos siguen funcionando | ### 2. Manda al usuario a autorizar Genera un `code_verifier` aleatorio (43–128 caracteres), su `code_challenge = base64url(sha256(verifier))` y un `state`. Guarda los dos en la sesión de tu usuario. ```text https://remolom.com/api/oauth/authorize ?response_type=code &client_id=ro_ci_… &redirect_uri=https://tu-app.com/callback &scope=events:read events:write &state=… &code_challenge=… &code_challenge_method=S256 ``` El usuario ve la pantalla de consentimiento en `/oauth/authorize`, elige la empresa y autoriza. Remolom vuelve a tu `redirect_uri` con `?code=ro_ac_…&state=…`, o con `?error=access_denied&state=…` si cancela. Comprueba siempre que `state` es el tuyo. ### 3. Cambia el código por tokens `POST https://remolom.com/api/oauth/token` (form-urlencoded o JSON). El código vale 60 segundos y un solo intento; si alguien lo vuelve a usar, se revoca el permiso que emitió. ```bash curl -X POST https://remolom.com/api/oauth/token \ -d grant_type=authorization_code \ -d code=ro_ac_… \ -d redirect_uri=https://tu-app.com/callback \ -d code_verifier=$VERIFIER \ -d client_id=ro_ci_… \ -d client_secret=ro_cs_… ``` Respuesta: ```json { "access_token": "ro_at_…", "token_type": "Bearer", "expires_in": 3600, "refresh_token": "ro_rt_…", "scope": "events:read events:write" } ``` El access token dura 1 hora y el refresh token 90 días. El token actúa en nombre de quien autorizó y sobre la empresa que eligió. ### 4. Renueva el token ```bash curl -X POST https://remolom.com/api/oauth/token \ -d grant_type=refresh_token -d refresh_token=ro_rt_… \ -d client_id=ro_ci_… -d client_secret=ro_cs_… ``` Cada renovación devuelve un refresh token nuevo y el anterior deja de valer. **Reusar** un refresh token ya usado (o mandar dos renovaciones a la vez) revoca el permiso entero: guarda siempre el último. ### 5. Revoca `POST /api/oauth/revoke` con `token`, `client_id` y `client_secret` (RFC 7009) revoca el permiso completo. Siempre responde 200 `{}`. La empresa también puede revocarlo en su panel, en **Apps conectadas**. ### Ejemplo completo en Node ```js import { createHash, randomBytes } from 'node:crypto' const CLIENT_ID = process.env.REMOLOM_CLIENT_ID const CLIENT_SECRET = process.env.REMOLOM_CLIENT_SECRET const REDIRECT_URI = 'https://tu-app.com/callback' // Paso 2: URL de autorización. Guarda verifier y state en la sesión del usuario. export function authorizeUrl(session) { session.verifier = randomBytes(32).toString('base64url') session.state = randomBytes(16).toString('base64url') const challenge = createHash('sha256').update(session.verifier).digest('base64url') const q = new URLSearchParams({ response_type: 'code', client_id: CLIENT_ID, redirect_uri: REDIRECT_URI, scope: 'events:read events:write', state: session.state, code_challenge: challenge, code_challenge_method: 'S256', }) return `https://remolom.com/api/oauth/authorize?${q}` } // Paso 3: en tu /callback. export async function callback(session, query) { if (query.error) throw new Error(query.error) if (query.state !== session.state) throw new Error('state no coincide') const res = await fetch('https://remolom.com/api/oauth/token', { method: 'POST', body: new URLSearchParams({ grant_type: 'authorization_code', code: query.code, redirect_uri: REDIRECT_URI, code_verifier: session.verifier, client_id: CLIENT_ID, client_secret: CLIENT_SECRET, }), }) if (!res.ok) throw new Error((await res.json()).error) return res.json() // { access_token, refresh_token, expires_in, scope } } ``` ### Ejemplo completo en Python ```python import base64, hashlib, os, secrets, requests from urllib.parse import urlencode CLIENT_ID = os.environ["REMOLOM_CLIENT_ID"] CLIENT_SECRET = os.environ["REMOLOM_CLIENT_SECRET"] REDIRECT_URI = "https://tu-app.com/callback" def authorize_url(session: dict) -> str: session["verifier"] = secrets.token_urlsafe(32) session["state"] = secrets.token_urlsafe(16) challenge = base64.urlsafe_b64encode(hashlib.sha256(session["verifier"].encode()).digest()).rstrip(b"=").decode() return "https://remolom.com/api/oauth/authorize?" + urlencode({ "response_type": "code", "client_id": CLIENT_ID, "redirect_uri": REDIRECT_URI, "scope": "events:read events:write", "state": session["state"], "code_challenge": challenge, "code_challenge_method": "S256", }) def callback(session: dict, args: dict) -> dict: if "error" in args: raise RuntimeError(args["error"]) if args.get("state") != session["state"]: raise RuntimeError("state no coincide") r = requests.post("https://remolom.com/api/oauth/token", data={ "grant_type": "authorization_code", "code": args["code"], "redirect_uri": REDIRECT_URI, "code_verifier": session["verifier"], "client_id": CLIENT_ID, "client_secret": CLIENT_SECRET, }) r.raise_for_status() return r.json() # access_token, refresh_token, expires_in, scope ``` ### Errores de OAuth - `401 { "error": "invalid_client" }`: `client_id` o `client_secret` incorrectos. También se aceptan por `Authorization: Basic`. - `400 { "error": "invalid_grant", "error_description": … }`: código caducado o usado, `redirect_uri` distinta, `code_verifier` que no casa o refresh token no válido. - `400 { "error": "unsupported_grant_type" }`: solo `authorization_code` y `refresh_token`. - Con el token: 401 si el permiso se revocó, la app se suspendió o quien autorizó ya no gestiona la empresa; 403 si falta el scope. --- # Eventos Crea, actualiza y cancela los eventos de tu empresa. Lo recomendable es el upsert por `externalId`: idempotente y sin duplicados. ## Rutas | Ruta | Scope | Qué hace | |---|---|---| | `GET /v1/events` | `events:read` | Eventos que no han terminado. Filtros: `from`, `to` (ISO), `status` (`published` o `cancelled`), `branchId`, `q`, `limit` (máx. 100, por defecto 50), `offset` | | `PUT /v1/events/external/:source/:externalId` | `events:write` | **Upsert**: crea (201) o actualiza (200) | | `GET /v1/events/external/:source/:externalId` | `events:read` | Evento por tu id | | `DELETE /v1/events/external/:source/:externalId` | `events:write` | Cancela por tu id | | `POST /v1/events` | `events:write` | Crea. Acepta `externalId` y `source`; 409 si ya existen | | `PATCH /v1/events/:id` | `events:write` | Cambia solo los campos que mandes | | `DELETE /v1/events/:id` | `events:write` | Cancela (no borra) | | `POST /v1/uploads` | `events:write` | Sube un póster (multipart `file`) | Las respuestas son `{ "event": EventDTO }` o `{ "events": [EventDTO] }`. ## Campos obligatorios | Campo | Regla | |---|---| | `title` | 3 a 120 caracteres | | `startsAt` | ISO 8601 (ver zonas horarias) | | `categories` | 1 a 3 categorías de la lista. También vale `category` con una sola | | Ubicación | Una de estas: `branchId` (se copia el lugar de la sede); `venueName` + `address` (se geocodifica la dirección); o `venueName` + `address` + `lat` + `lng` | | Precio | `"isFree": true` sin precios, o `"isFree": false` con `prices` (y `currency`, por defecto la del país) | ## Campos opcionales | Campo | Notas | |---|---| | `description` | Hasta 5000 caracteres | | `endsAt` | Por defecto `startsAt` + 3 h. `null` = sin fin | | `prices` | `[{ "name": "General", "priceCents": 1850, "capacity": 100 }]`, hasta 10. Importes en unidad menor de la moneda | | `currency` | ISO 4217 (`EUR`, `COP`, `USD`…). Por defecto la del país | | `country` | ISO 3166-1 (`ES`, `CO`…). Por defecto el de la sede o la empresa | | `timezone` | IANA (`Europe/Madrid`). Por defecto, la del lugar | | `capacity` | Aforo total. Sin él, sin límite | | `subcategory` | Slug de una subcategoría de la categoría principal (la primera de `categories`), de [`GET /api/categories`](#subcategorias). Otra cosa: 422. `null` la quita | | `posterUrl` / `posterKey` | Póster por URL o subido (ver abajo) | | `ticketUrl` | Venta externa (ver abajo) | | `externalId`, `source` | Tu id del evento y su origen | Si falta un dato obligatorio o tiene mal formato la respuesta es 422; si incumple una regla (de pago sin precios, fin antes del inicio, cupo de un precio mayor que el aforo), 400. ## Upsert por externalId `PUT /v1/events/external/:source/:externalId` es la forma recomendada de sincronizar tu sistema con Remolom: - `externalId` es el id del evento en tu sistema (hasta 200 caracteres). - `source` identifica de dónde viene (hasta 50 caracteres): `mi-web`, `taquilla`, `wordpress`… Así el mismo id en dos sistemas no choca. - Si no existe, se crea y responde **201**. Si existe, se actualiza y responde **200**. Si estaba cancelado, se reactiva. - Al actualizar, los precios con el mismo nombre conservan su id y sus ventas. - Manda siempre el evento completo: es lo más sencillo y evita estados a medias. ```bash curl -X PUT https://remolom.com/api/v1/events/external/taquilla/obra-123 \ -H "Authorization: Bearer $REMOLOM_KEY" -H "Content-Type: application/json" \ -d '{ "title": "La vida es sueño", "categories": ["cultura"], "startsAt": "2026-12-12T20:30", "branchId": "8a6f1c2e-…", "isFree": false, "prices": [{ "name": "Platea", "priceCents": 2500 }, { "name": "Anfiteatro", "priceCents": 1500 }], "posterUrl": "https://mi-web.com/img/vida-es-sueno.jpg" }' ``` ```js async function upsert(source, externalId, event) { const res = await fetch(`https://remolom.com/api/v1/events/external/${source}/${encodeURIComponent(externalId)}`, { method: 'PUT', headers: { Authorization: `Bearer ${process.env.REMOLOM_KEY}`, 'Content-Type': 'application/json' }, body: JSON.stringify(event), }) const body = await res.json() if (!res.ok) throw new Error(`${res.status} ${body.error}`) return body.event } ``` ```python import os, requests from urllib.parse import quote def upsert(source: str, external_id: str, event: dict) -> dict: r = requests.put( f"https://remolom.com/api/v1/events/external/{source}/{quote(external_id, safe='')}", headers={"Authorization": f"Bearer {os.environ['REMOLOM_KEY']}"}, json=event, ) if not r.ok: raise RuntimeError(f"{r.status_code} {r.json()['error']}") return r.json()["event"] ``` `POST /v1/events` también acepta `externalId` y `source` (por defecto `"default"`), pero devuelve 409 si ya existen: úsalo solo si quieres que falle ante un duplicado. ## Pósters Dos formas: - **Por URL**: manda `posterUrl`. Remolom descarga la imagen (JPG, PNG o WebP, hasta 10 MB) y la guarda. Si la URL no cambia, no se vuelve a descargar. `"posterUrl": null` quita el póster. Si la descarga falla: 422 `No se pudo descargar el póster: …`. - **Subida**: `POST /v1/uploads` con el archivo en el campo `file` (multipart, hasta 10 MB). Devuelve `{ posterKey, url }`; manda ese `posterKey` en el evento. ```bash curl -X POST https://remolom.com/api/v1/uploads \ -H "Authorization: Bearer $REMOLOM_KEY" -F file=@poster.jpg # { "posterKey": "…", "url": "https://media.remolom.com/…" } ``` ## Venta de entradas externa (ticketUrl) Si vendes las entradas en tu web o en otra plataforma, manda `ticketUrl` (solo `https://`, hasta 500 caracteres). La ficha del evento muestra el botón **Comprar entradas** con ese enlace y la venta en Remolom se desactiva (`"sales": null` en el EventDTO). Sin `ticketUrl`, un evento de pago se vende en Remolom. ## Zonas horarias - **Con offset o `Z`** (`2026-12-05T21:00:00+01:00`, `2026-12-05T20:00:00Z`): es un instante exacto. - **Sin offset** (`2026-12-05T21:00`): es la hora local del lugar del evento. Es lo más cómodo: manda la hora que pone en el cartel. - La zona del evento es `timezone` si la mandas (IANA, por ejemplo `America/Bogota`); si no, la del país del lugar (Canarias se detecta por coordenadas). - La API siempre devuelve las fechas en UTC (`…Z`) y el EventDTO trae `timezone` para mostrarlas en hora local. ## Categorías | Slug | Para | |---|---| | `musica` | Música: conciertos, festivales, DJ | | `cultura` | Cultura: teatro, cine, museos, exposiciones | | `gastronomia` | Gastronomía: catas, mercados, menús | | `standup` | Stand-up y comedia | | `ferias` | Ferias y mercadillos | | `ocio` | Ocio, fiestas y quedadas | | `deporte` | Deporte: partidos, carreras, torneos | ## Subcategorías Cada categoría tiene subcategorías (jazz, teatro, fútbol…) que mantiene Remolom. La lista es pública, sin clave: ```bash curl https://remolom.com/api/categories ``` ```json { "categories": [ { "slug": "musica", "subcategories": [{ "slug": "jazz", "name": { "es": "Jazz", "en": "Jazz", "pt-BR": "Jazz", "fr": "Jazz" } }] } ] } ``` - `subcategory` lleva el `slug` y debe ser de la categoría principal del evento; si no, la respuesta es 422. - Si al editar cambias la categoría principal sin mandar `subcategory`, se quita la que ya no encaja. - El EventDTO trae `subcategory` (slug) y `subcategoryName` (nombre por idioma; si falta uno, usa `es`). ## EventDTO ```json { "event": { "id": "3f0b…", "title": "Concierto de jazz", "description": "", "category": "musica", "categories": ["musica"], "subcategory": null, "subcategoryName": null, "isFree": false, "priceCents": 1850, "currency": "EUR", "country": "ES", "prices": [{ "id": "…", "name": "General", "priceCents": 1850, "capacity": null, "remaining": null, "soldOut": false }], "timezone": "Europe/Madrid", "startsAt": "2026-12-05T20:00:00.000Z", "endsAt": "2026-12-05T23:00:00.000Z", "venueName": "Sala Clamores", "address": "Calle Alburquerque 14, Madrid", "lat": 40.4316, "lng": -3.7003, "posterUrl": "https://media.remolom.com/…", "status": "published", "sales": null, "ticketUrl": "https://mi-web.com/entradas/jazz", "externalId": "jazz-2026-12-05", "source": "mi-web", "test": false, "createdAt": "2026-11-14T10:00:00.000Z" } } ``` El EventDTO trae más campos (empresa, sede, aforo restante…). La lista completa está en el [OpenAPI](https://remolom.com/api/v1/openapi.json). --- # Sedes Las sedes son los lugares fijos de tu empresa. Publica en una sede con `branchId` y olvídate de direcciones y coordenadas. Las sedes se crean y se editan en [Mi empresa → Sedes](https://remolom.com/dashboard/company?tab=branches). Por API se leen. ## GET /v1/branches Scope `events:read`. Devuelve las sedes activas de la empresa. ```bash curl https://remolom.com/api/v1/branches -H "Authorization: Bearer $REMOLOM_KEY" ``` ```json { "branches": [ { "id": "8a6f1c2e-…", "name": "Sala Clamores", "address": "Calle Alburquerque 14, Madrid", "city": "Madrid", "country": "ES", "lat": 40.4316, "lng": -3.7003 } ] } ``` ```js const res = await fetch('https://remolom.com/api/v1/branches', { headers: { Authorization: `Bearer ${process.env.REMOLOM_KEY}` } }) const { branches } = await res.json() ``` ```python branches = requests.get("https://remolom.com/api/v1/branches", headers={"Authorization": f"Bearer {os.environ['REMOLOM_KEY']}"}).json()["branches"] ``` ## Publicar en una sede Manda `branchId` en el evento. Al crearlo, `venueName`, `address`, `lat` y `lng` se copian de la sede, y la zona horaria sale de sus coordenadas. Si mandas también `venueName` (por ejemplo, "Sala pequeña"), tu valor gana. ```json { "title": "Partido amistoso", "categories": ["deporte"], "startsAt": "2026-12-06T10:00", "branchId": "8a6f1c2e-…", "isFree": true } ``` Para filtrar los eventos de una sede: `GET /v1/events?branchId=8a6f1c2e-…`. --- # Entradas y estadísticas Consulta las entradas vendidas de un evento, sus titulares y el resumen de ventas. Necesita el scope `tickets:read`. Las entradas solo existen cuando la venta es en Remolom (eventos sin `ticketUrl`). Para enterarte al momento de cada venta o validación usa los [webhooks](https://remolom.com/developers/webhooks) `ticket.*`. ## GET /v1/events/:id/tickets Filtros: `status` (`valid`, `checked_in` o `voided`), `limit` (máx. 500, por defecto 100) y `offset`. ```bash curl "https://remolom.com/api/v1/events/3f0b…/tickets?status=valid&limit=500" -H "Authorization: Bearer $REMOLOM_KEY" ``` ```json { "tickets": [ { "id": "…", "type": "General", "priceCents": 1850, "currency": "EUR", "status": "valid", "buyerName": "Ana Pérez", "buyerEmail": "ana@example.com", "purchasedAt": "2026-11-20T18:02:11.000Z", "checkedInAt": null } ] } ``` - `type` es el nombre del precio (`General` si no tiene). - `buyerName` y `buyerEmail` son del titular actual: si la entrada se transfirió, el del nuevo titular. - Son datos personales: trátalos según tu política de privacidad y la de [Remolom](https://remolom.com/privacy). ## GET /v1/events/:id/stats ```bash curl https://remolom.com/api/v1/events/3f0b…/stats -H "Authorization: Bearer $REMOLOM_KEY" ``` ```json { "sold": 142, "checkedIn": 97, "revenueCents": 262700, "currency": "EUR" } ``` - `sold`: entradas no anuladas. - `checkedIn`: de ellas, las validadas en puerta. - `revenueCents`: suma de los pedidos pagados, en la unidad menor de `currency`. ```python stats = requests.get(f"https://remolom.com/api/v1/events/{event_id}/stats", headers={"Authorization": f"Bearer {key}"}).json() print(f"{stats['checkedIn']}/{stats['sold']} dentro") ``` --- # Webhooks Remolom te manda un `POST` firmado cuando pasa algo en tus eventos o entradas: publicaciones, cambios, ventas, reembolsos y validaciones en puerta. ## Crear un webhook En [Mi empresa → Webhooks](https://remolom.com/dashboard/company?tab=webhooks) añade la URL (https y pública), elige los tipos de evento y el modo (**Real** o **Prueba**). Al crearlo verás el secreto `whsec_…` **una sola vez**: guárdalo para verificar la firma. Puedes rotarlo cuando quieras; el anterior deja de valer al momento. También por API, con el scope `webhooks:manage`: | Ruta | Respuesta | |---|---| | `GET /v1/webhooks` | `{ webhooks: [{ id, url, events, active, mode, createdAt, failingSince }] }` | | `POST /v1/webhooks` `{ url, events, mode? }` | `{ webhook, secret }` | | `PATCH /v1/webhooks/:id` `{ url?, events?, active? }` | `{ webhook }` | | `DELETE /v1/webhooks/:id` | `{ ok: true }` | | `POST /v1/webhooks/:id/rotate` | `{ webhook, secret }` | | `POST /v1/webhooks/:id/test` | `{ ok, code, error }`: envía un `ping` al momento | | `GET /v1/webhooks/:id/deliveries` | Las 50 últimas entregas con su estado, intentos y último código | Máximo 10 webhooks por empresa. Los endpoints de **prueba** solo reciben sucesos de prueba (de claves `rk_test_`) y los **reales** solo los reales. ## Qué recibes `POST` a tu URL con `Content-Type: application/json` y estas cabeceras: | Cabecera | Valor | |---|---| | `Remolom-Signature` | `t=,v1=` | | `Remolom-Event` | El tipo, por ejemplo `ticket.sold` | | `Remolom-Delivery` | Id de esta entrega | | `User-Agent` | `Remolom-Webhooks/1.0` | Cuerpo: `{ id, type, createdAt, test, data }`. El `id` es el mismo en todos los reintentos del mismo suceso: **úsalo para deduplicar**. ## Tipos de evento | Tipo | Cuándo | `data` | |---|---|---| | `event.created` | Se crea un evento (web, app, API, MCP, importador o feed) | `{ event: EventDTO }` | | `event.updated` | Cambia algún dato, se reactiva un cancelado o moderación lo vuelve a publicar | `{ event: EventDTO }` | | `event.cancelled` | El organizador lo cancela (también `DELETE /v1/…` o si desaparece de un feed) | `{ event: EventDTO }` | | `event.hidden` | Moderación de Remolom lo retira | `{ event: EventDTO }` | | `ticket.sold` | Un pedido se paga (o se reserva gratis) | `TicketData` con todas las entradas del pedido | | `ticket.refunded` | Se reembolsa un pedido | `TicketData` con las entradas anuladas | | `ticket.transferred` | El titular transfiere una entrada | `TicketData` con esa entrada y el nuevo `holderName` | | `ticket.checked_in` | Se valida en puerta (también lecturas sin conexión al sincronizar) | `TicketData` con esa entrada | | `ping` | Botón **Enviar prueba** o `POST …/test` | `{ message, webhookId }` | `TicketData = { eventId, orderId, tickets: [{ id, priceId, priceName, holderName, checkedInAt, gate, transferredAt, voidedAt, createdAt }] }`. No lleva emails: los datos del comprador se piden con [GET /v1/events/:id/tickets](https://remolom.com/developers/tickets). ### event.created, event.updated, event.cancelled y event.hidden ```json { "id": "6f1c2a…", "type": "event.created", "createdAt": "2026-11-14T10:00:00.000Z", "test": false, "data": { "event": { "id": "3f0b…", "title": "Concierto de jazz", "status": "published", "startsAt": "2026-12-05T20:00:00.000Z", "externalId": "jazz-2026-12-05", "source": "mi-web", "test": false } } } ``` En `event.cancelled` y `event.hidden` el evento llega con `"status": "cancelled"`. El EventDTO es el mismo de la API (aquí recortado). ### ticket.sold ```json { "id": "9b2e…", "type": "ticket.sold", "createdAt": "2026-11-20T18:02:11.000Z", "test": false, "data": { "eventId": "3f0b…", "orderId": "c41d…", "tickets": [ { "id": "t1…", "priceId": "p1…", "priceName": "General", "holderName": "Ana Pérez", "checkedInAt": null, "gate": null, "transferredAt": null, "voidedAt": null, "createdAt": "2026-11-20T18:02:11.000Z" }, { "id": "t2…", "priceId": "p1…", "priceName": "General", "holderName": "Ana Pérez", "checkedInAt": null, "gate": null, "transferredAt": null, "voidedAt": null, "createdAt": "2026-11-20T18:02:11.000Z" } ] } } ``` ### ticket.refunded ```json { "id": "a7c0…", "type": "ticket.refunded", "createdAt": "2026-11-22T09:15:00.000Z", "test": false, "data": { "eventId": "3f0b…", "orderId": "c41d…", "tickets": [ { "id": "t1…", "priceId": "p1…", "priceName": "General", "holderName": "Ana Pérez", "checkedInAt": null, "gate": null, "transferredAt": null, "voidedAt": "2026-11-22T09:15:00.000Z", "createdAt": "2026-11-20T18:02:11.000Z" } ] } } ``` ### ticket.transferred ```json { "id": "d3f9…", "type": "ticket.transferred", "createdAt": "2026-11-25T12:00:00.000Z", "test": false, "data": { "eventId": "3f0b…", "orderId": "c41d…", "tickets": [ { "id": "t2…", "priceId": "p1…", "priceName": "General", "holderName": "Luis Gómez", "checkedInAt": null, "gate": null, "transferredAt": "2026-11-25T12:00:00.000Z", "voidedAt": null, "createdAt": "2026-11-20T18:02:11.000Z" } ] } } ``` ### ticket.checked_in ```json { "id": "e8a1…", "type": "ticket.checked_in", "createdAt": "2026-12-05T21:04:11.000Z", "test": false, "data": { "eventId": "3f0b…", "orderId": "c41d…", "tickets": [ { "id": "t1…", "priceId": "p1…", "priceName": "General", "holderName": "Ana Pérez", "checkedInAt": "2026-12-05T21:04:10.000Z", "gate": "Puerta 1", "transferredAt": null, "voidedAt": null, "createdAt": "2026-11-20T18:02:11.000Z" } ] } } ``` ### ping ```json { "id": "f0e2…", "type": "ping", "createdAt": "2026-11-14T10:00:00.000Z", "test": true, "data": { "message": "Prueba de webhook de Remolom", "webhookId": "5b7a…" } } ``` ## Verificar la firma `v1 = hex(hmac_sha256(secreto, t + "." + cuerpo_crudo))`. 1. Calcula la firma sobre el cuerpo **tal cual llega**, antes de parsear el JSON. 2. Compárala en tiempo constante. 3. Rechaza la petición si `t` tiene más de 5 minutos (evita reenvíos). ### Node ```js import { createHmac, timingSafeEqual } from 'node:crypto' export function verify(secret, rawBody, header) { const { t, v1 } = Object.fromEntries(header.split(',').map((p) => p.split('='))) const expected = createHmac('sha256', secret).update(`${t}.${rawBody}`).digest('hex') const ok = v1?.length === expected.length && timingSafeEqual(Buffer.from(v1), Buffer.from(expected)) return ok && Math.abs(Date.now() / 1000 - Number(t)) < 300 } // Express: el cuerpo crudo, sin express.json() en esta ruta. app.post('/webhooks/remolom', express.raw({ type: 'application/json' }), (req, res) => { if (!verify(process.env.REMOLOM_WEBHOOK_SECRET, req.body.toString('utf8'), req.get('Remolom-Signature') ?? '')) return res.sendStatus(400) const evt = JSON.parse(req.body) // deduplica por evt.id y responde rápido; el trabajo pesado, en segundo plano res.sendStatus(200) }) ``` ### Python ```python import hashlib, hmac, os, time from flask import Flask, request app = Flask(__name__) def verify(secret: str, raw_body: bytes, header: str) -> bool: parts = dict(p.split("=", 1) for p in header.split(",")) expected = hmac.new(secret.encode(), f"{parts['t']}.".encode() + raw_body, hashlib.sha256).hexdigest() return hmac.compare_digest(expected, parts.get("v1", "")) and abs(time.time() - int(parts["t"])) < 300 # Flask @app.post("/webhooks/remolom") def remolom(): if not verify(os.environ["REMOLOM_WEBHOOK_SECRET"], request.get_data(), request.headers.get("Remolom-Signature", "")): return "", 400 evt = request.get_json() return "", 200 ``` ### PHP ```php function verify(string $secret, string $rawBody, string $header): bool { parse_str(str_replace(',', '&', $header), $p); $expected = hash_hmac('sha256', $p['t'] . '.' . $rawBody, $secret); return hash_equals($expected, $p['v1'] ?? '') && abs(time() - (int) $p['t']) < 300; } $raw = file_get_contents('php://input'); if (!verify(getenv('REMOLOM_WEBHOOK_SECRET'), $raw, $_SERVER['HTTP_REMOLOM_SIGNATURE'] ?? '')) { http_response_code(400); exit; } $evt = json_decode($raw, true); http_response_code(200); ``` ## Reintentos - Cuenta como entregado un 2xx en menos de 10 segundos. Las redirecciones no se siguen: cuentan como fallo. - Si falla, se reintenta a los 1 min, 5 min, 30 min, 2 h, 6 h y 12 h (unas 21 h en total). Después la entrega queda como fallida. - Si un endpoint lleva 3 días seguidos fallando se desactiva y avisamos a los owners y admins de la empresa. Una entrega correcta reinicia la cuenta. Reactívalo desde el panel o con `PATCH { "active": true }`. - El orden no está garantizado: usa `createdAt` y el estado del propio objeto. - Responde rápido y procesa en segundo plano. ## Probar - Botón **Enviar prueba** en el panel, o `POST /v1/webhooks/:id/test`: manda un `ping` al momento, sin reintentos, y te devuelve `{ ok, code, error }`. - Para probar el flujo completo, crea un webhook en modo **Prueba** y usa una clave `rk_test_`: cada evento que crees dispara `event.created` con `"test": true`. - En el panel ves las últimas entregas de cada webhook con su código de respuesta. --- # Sincronización de feeds Si tu agenda ya existe como iCal, CSV o una web con datos estructurados, Remolom la sincroniza sola: crea, actualiza y cancela eventos sin que programes nada. ## Configurar En [Mi empresa → Importar](https://remolom.com/dashboard/company?tab=import), sección **Sincronización automática**: - **Por URL**: un calendario iCal (`.ics`) o una página con datos `schema.org/Event` (JSON-LD, microdata u OpenGraph). Se descarga cada 1, 6 o 24 horas. - **Por archivo**: sube un `.ics` o un `.csv`. Se sincroniza al subirlo y cada vez que lo reemplaces. Máximo 10 feeds por empresa. Cada feed tiene su `source` (por defecto `feed-xxxxxxxx`) y publica como la persona que lo creó. Desde el panel puedes **Sincronizar ahora**, reemplazar el archivo, pausar o quitar el feed; los eventos ya creados se quedan. ## Cómo sincroniza 1. Descarga la URL o lee el archivo. Si el contenido no ha cambiado desde la última vez, no hace nada. 2. Cada evento del feed lleva un id estable (`externalId`): - **iCal**: el `UID` de cada `VEVENT`. - **CSV**: la columna `id`. - Si falta: un hash de título, inicio y lugar. Cambiar cualquiera de esos tres crea un evento nuevo, así que usa un id siempre que puedas. 3. Hace un upsert de cada evento: crea los nuevos y actualiza los que cambian, igual que `PUT /v1/events/external/:source/:externalId`. También dispara los webhooks. 4. Cancela los eventos futuros de ese feed que ya no aparecen. Un feed que llega vacío no cancela nada (sería una descarga rota). La última ejecución muestra cuántos eventos se crearon, actualizaron y cancelaron, y los errores de cada uno. ## Plantilla CSV Descarga la [plantilla](https://remolom.com/plantilla-eventos.csv). Columnas fijas, separadas por `,` o `;`: ```csv id,titulo,descripcion,categoria,inicio,fin,lugar,direccion,lat,lng,sede,gratis,precio,moneda jazz-2026-12-05,"Concierto de jazz","Trío en directo",musica,2026-12-05 21:00,2026-12-05 23:00,Sala Clamores,"Calle Alburquerque 14, Madrid",40.4316,-3.7003,,no,18.50,EUR amistoso-2026-12-06,"Partido amistoso","",deporte,2026-12-06 10:00,,,,,,Sede Medellín,si,, ``` | Columna | Notas | |---|---| | `id` | Tu id del evento. **Imprescindible** para que los cambios actualicen en vez de duplicar | | `titulo` | Obligatorio | | `categoria` | Un slug de la [lista](https://remolom.com/developers/events#categorias). Por defecto `ocio` | | `inicio`, `fin` | Hora local del lugar, `AAAA-MM-DD HH:MM` | | `lugar`, `direccion` | Sin `lat`/`lng` la dirección se geocodifica | | `sede` | Nombre exacto de una de tus sedes: copia su lugar | | `gratis` | `si` o `no` | | `precio`, `moneda` | En unidades normales (`18.50`), no en céntimos. Sin moneda, la del país | ## iCal Se leen `UID`, `SUMMARY`, `DESCRIPTION`, `DTSTART` y `DTEND` (con `TZID`, `Z` o flotantes, que se toman como hora local), `LOCATION`, `GEO`, `URL` y `CATEGORIES`. Los `VEVENT` con `STATUS:CANCELLED` se saltan. Las repeticiones (`RRULE`) no se expanden: publica cada fecha como su propio `VEVENT` con su `UID`. ```text BEGIN:VEVENT UID:jazz-2026-12-05@mi-web.com SUMMARY:Concierto de jazz DTSTART;TZID=Europe/Madrid:20261205T210000 DTEND;TZID=Europe/Madrid:20261205T230000 LOCATION:Sala Clamores, Calle Alburquerque 14, Madrid GEO:40.4316;-3.7003 END:VEVENT ``` ## Importación manual En la misma pestaña puedes importar una sola vez (sin sincronizar) desde una URL, un iCal o un CSV, con vista previa para corregir fecha, sede y categoría y aviso de posibles duplicados. La importación manual no usa `externalId`: si quieres que los cambios se actualicen, usa un feed o la API. --- # MCP Servidor MCP remoto para que un asistente de IA (Claude Code, Claude Desktop u otro cliente MCP) publique y gestione los eventos de tu empresa en lenguaje natural. - URL: `https://remolom.com/api/mcp` (Streamable HTTP, respuestas JSON, sin sesión). - Autenticación: la misma cabecera `Authorization: Bearer` con una clave `rk_live_` / `rk_test_` o un access token OAuth. - Mismas validaciones, permisos y límite (60 peticiones por minuto) que la API REST. ## Herramientas | Herramienta | Scope | Qué hace | |---|---|---| | `listar_eventos` | `events:read` | Eventos de la empresa (los que no han terminado) | | `listar_sedes` | `events:read` | Sedes con id, dirección y coordenadas | | `crear_evento` | `events:write` | Publica un evento (mismos campos que `POST /v1/events`) | | `actualizar_evento` | `events:write` | Cambia campos de un evento por `id` | | `cancelar_evento` | `events:write` | Cancela un evento por `id` | Con una clave de solo lectura solo aparecen las herramientas de lectura. Consejo: empieza con una clave `rk_test_` para que nada sea público mientras pruebas. ## Claude Code ```bash claude mcp add --transport http remolom https://remolom.com/api/mcp --header "Authorization: Bearer rk_live_…" ``` Comprueba con `claude mcp list` y, dentro de Claude Code, con `/mcp`. ## Claude Desktop Claude Desktop habla stdio con los servidores locales: usa el puente `mcp-remote` en `claude_desktop_config.json` (Ajustes → Desarrollador → Editar configuración): ```json { "mcpServers": { "remolom": { "command": "npx", "args": ["-y", "mcp-remote", "https://remolom.com/api/mcp", "--header", "Authorization:${REMOLOM_AUTH}"], "env": { "REMOLOM_AUTH": "Bearer rk_live_…" } } } } ``` Reinicia Claude Desktop. Después pídele, por ejemplo: «Publica en la sede de Medellín un partido amistoso el sábado a las 10:00, gratis». ## Sin cliente MCP Es JSON-RPC 2.0 sobre `POST`, así que puedes probarlo con curl: ```bash curl https://remolom.com/api/mcp -H "Authorization: Bearer $REMOLOM_KEY" -H "Content-Type: application/json" \ -d '{ "jsonrpc": "2.0", "id": 1, "method": "tools/list" }' ``` Métodos: `initialize`, `ping`, `tools/list` y `tools/call`. El resultado de cada herramienta es el JSON de la respuesta equivalente de `/v1`, con `isError: true` si falló. --- # Úsalo con IA Dale a tu asistente de IA todo lo que necesita para integrar Remolom: la documentación en Markdown, una skill de Claude lista para instalar y el servidor MCP. ## llms.txt - [/llms.txt](https://remolom.com/llms.txt): índice de la documentación en el formato de [llmstxt.org](https://llmstxt.org), con un enlace al Markdown de cada sección. - [/llms-full.txt](https://remolom.com/llms-full.txt): toda la documentación en un solo Markdown. Pégalo en el contexto de tu modelo o pásale la URL. Se generan desde los mismos archivos que estas páginas: siempre están al día. ## Skill de Claude La skill `remolom-api` enseña a Claude a integrar Remolom: cuándo usar el upsert, qué campos son obligatorios, cómo verificar la firma de los webhooks, cómo probar con claves `rk_test_` y los errores típicos. Claude la carga sola cuando le pides publicar o sincronizar eventos, montar webhooks o conectar con OAuth. - Descarga: [remolom-skill.zip](https://remolom.com/developers/remolom-skill.zip). - O léela en línea: [SKILL.md](https://remolom.com/skills/remolom/SKILL.md), con [eventos.md](https://remolom.com/skills/remolom/eventos.md), [webhooks.md](https://remolom.com/skills/remolom/webhooks.md) y [oauth.md](https://remolom.com/skills/remolom/oauth.md). Instalación en Claude Code (para todos tus proyectos): ```bash curl -LO https://remolom.com/developers/remolom-skill.zip unzip remolom-skill.zip -d ~/.claude/skills/ # queda en ~/.claude/skills/remolom-api/SKILL.md ``` Para un solo proyecto, descomprímela en `.claude/skills/` dentro del repositorio. En Claude.ai o Claude Desktop, súbela como skill desde Ajustes → Capacidades. ## MCP Para que el asistente opere directamente sobre tus eventos (no solo escriba código), conecta el [servidor MCP](https://remolom.com/developers/mcp) con una clave de prueba mientras experimentas. --- # Errores y límites Todos los errores tienen la misma forma y un código HTTP estable. Los límites protegen a todos los usuarios de la API. ## Formato ```json { "error": "prices es obligatorio si el evento no es gratis" } ``` El mensaje está en español y es legible: muéstralo o regístralo tal cual. Para decidir qué hacer, usa el código. ## Códigos | Código | Significa | Qué hacer | |---|---|---| | `400` | Regla del evento no cumplida (de pago sin precios, fin antes del inicio, moneda o zona no válida…) | Corrige los datos; no reintentes igual | | `401` | Clave o token ausente, inválido o revocado, o quien la creó ya no gestiona la empresa | Revisa la cabecera `Authorization` o crea otra clave | | `403` | Falta el scope (`La clave no tiene el permiso events:write`) | Crea una clave o pide un token con ese permiso | | `404` | El recurso no existe, es de otra empresa o de otro modo (live/test) | No se distingue a propósito | | `409` | Conflicto: `externalId` ya existe en `POST`, entradas ya vendidas en un precio que quitas, límite de claves o webhooks | Usa el upsert o ajusta el cambio | | `413` | Imagen demasiado grande | Hasta 10 MB | | `422` | Formato inválido: falta un campo obligatorio, tipo incorrecto, dirección no encontrada o póster que no se pudo descargar | Corrige los datos | | `429` | Demasiadas peticiones | Espera y reintenta con backoff | | `5xx` | Error nuestro | Reintenta con backoff; el upsert es idempotente | Los errores de OAuth siguen el RFC 6749 (`invalid_client`, `invalid_grant`…); los ves en [Autenticación](https://remolom.com/developers/authentication#errores-de-oauth). ## Límites | Qué | Límite | |---|---| | Peticiones a `/v1` y al MCP | 60 por minuto por clave o por permiso OAuth | | `GET /v1/events` | `limit` hasta 100 | | `GET /v1/events/:id/tickets` | `limit` hasta 500 | | Pósters | JPG, PNG o WebP, hasta 10 MB | | Claves de API activas | 2 (gratis) o 10 (PRO) por empresa | | Webhooks | 10 por empresa | | Feeds | 10 por empresa; archivos hasta 3 MB | | Apps OAuth | 10 por persona | | Eventos de prueba | Se borran a los 7 días | | Access token OAuth | 1 hora; refresh token, 90 días | ## Reintentos recomendados - Reintenta solo `429` y `5xx`, con espera exponencial (1 s, 2 s, 4 s…). - Con el upsert (`PUT /v1/events/external/…`) reintentar nunca duplica eventos. --- # Changelog Cambios de la API pública de Remolom. Las versiones nuevas no rompen lo anterior: los campos y rutas nuevos se añaden. ## 15 de noviembre de 2026: subcategorías - `subcategory` deja de ser texto libre: es el slug de una subcategoría de la categoría principal, de `GET /api/categories`. Un valor que no está en la lista da 422. Los eventos existentes ya tienen su texto convertido a slug. - El EventDTO añade `subcategoryName` (nombre en es, en, pt-BR y fr). ## 14 de noviembre de 2026: plataforma para desarrolladores - **Upsert por id externo**: `PUT /v1/events/external/:source/:externalId` crea o actualiza; `GET` y `DELETE` sobre la misma ruta. `POST /v1/events` acepta `externalId` y `source`. - **Pósters** por URL (`posterUrl`) o subidos con `POST /v1/uploads`. - **Venta externa** con `ticketUrl`: botón «Comprar entradas» y sin venta en Remolom. - `endsAt` opcional (por defecto inicio + 3 h) y geocodificación de la dirección si no mandas coordenadas. - **Claves de prueba** `rk_test_`: eventos privados que se borran a los 7 días. - **Entradas y estadísticas**: `GET /v1/events/:id/tickets` y `GET /v1/events/:id/stats` (scope `tickets:read`). - **Webhooks** firmados (`event.*`, `ticket.*`, `ping`) con reintentos durante 21 h, también por API (`/v1/webhooks`, scope `webhooks:manage`). - **OAuth** para plataformas: authorization code con PKCE, refresh con rotación, revocación, y edición de apps y rotación del `client_secret` (`PATCH /api/oauth/clients/:id`, `POST /api/oauth/clients/:id/rotate-secret`). - **Sincronización de feeds** por URL o archivo (iCal, CSV con columna `id`, webs con `schema.org/Event`). - **OpenAPI 3.1** en `/api/v1/openapi.json`. - Documentación nueva, `llms.txt`, `llms-full.txt` y skill de Claude. ## 13 de noviembre de 2026: v1 - Claves de API por empresa con permisos `events:read` y `events:write`. - `GET`, `POST`, `PATCH` y `DELETE` (cancelar) de eventos en `/v1/events`, y `GET /v1/branches`. - Fechas sin offset en hora local del lugar e importes en unidad menor de la moneda. - Servidor MCP en `/api/mcp` con `listar_eventos`, `crear_evento`, `actualizar_evento`, `cancelar_evento` y `listar_sedes`. - Importador del panel desde URL, iCal y CSV.