Hace unas semanas metí un pantallazo de un dashboard de facturación en una llamada a la API y le pedí al modelo el total del mes.
Me devolvió una cifra. Redonda, con su símbolo de euro, con toda la seguridad del mundo.
Estaba mal. No un poco mal: mal de otro trimestre.
Mi primer reflejo fue culpar al OCR. Craso error, porque ahí no había ningún OCR. Y ese fue el momento en el que entendí que llevaba meses usando un modelo multimodal sin tener ni idea de lo que pasaba entre mi fetch y la respuesta.
El modelo no leyó mi dashboard. Lo convirtió en tokens y predijo qué números encajaban ahí.
Qué es un modelo multimodal
Un modelo multimodal es un modelo de IA que acepta más de un tipo de entrada —texto, imagen, audio o vídeo— porque convierte todas esas entradas a vectores del mismo espacio y las procesa con un único transformer. No hay un "módulo de visión" que mira y luego le cuenta al modelo lo que hay: todo acaba siendo la misma sopa de números, y el modelo sigue haciendo lo único que sabe hacer, predecir el siguiente token.
Lo esencial, antes de entrar en detalle:
- Entrada no es salida. Que un modelo acepte imágenes no significa que las genere. Claude entiende imágenes; no las produce ni las edita.
- Se factura por parches. Claude trocea la imagen en bloques de 28×28 px y cobra cada bloque como un visual token.
- El coste es de prompt. Una captura de 1000×1000 px son 1.296 tokens de entrada antes de que el modelo escriba una palabra.
- El conteo es aproximado. La documentación de Anthropic lo admite: los conteos de objetos y las coordenadas no son exactos.
Cómo funciona: tu imagen no entra como imagen, entra como tokens
Un modelo multimodal procesa una imagen en tres pasos: un encoder la trocea en parches y convierte cada parche en un vector, una capa de proyección lleva esos vectores a la misma dimensionalidad que los embeddings de texto, y el transformer los mezcla con los tokens de tu prompt como si fueran palabras. Si ya tienes claro que la IA no piensa, predice, es una extensión bastante elegante de la misma idea.
Un LLM de texto tiene un tokenizador: parte tu string en trozos y a cada trozo le asigna un vector de N dimensiones. Ese vector es lo que come el transformer.
Un modelo multimodal añade una pieza delante: un encoder por cada modalidad. Para imagen suele ser un Vision Transformer que trocea el bitmap en parches cuadrados y convierte cada parche en un vector. Para audio, algo equivalente sobre el espectrograma.
Después viene el truco de todo esto: una capa de proyección que traduce esos vectores a la misma dimensionalidad que los embeddings de texto. Pasada esa capa, el transformer los procesa con la misma maquinaria: no hay una ruta especial para lo visual. El vector del parche 47 de tu JPEG y el de la palabra "factura" son vecinos en el mismo espacio, aunque el modelo sepa perfectamente cuál vino de dónde.
Anthropic lo documenta de forma literal: Claude ve las imágenes en parches de 28×28 píxeles y a cada parche lo llama visual token. No es una metáfora divulgativa, es la unidad de facturación.
El detalle que rompe la intuición: la secuencia final es una lista plana donde los tokens de la imagen y los de tu prompt están mezclados, atendiéndose unos a otros con el mismo mecanismo de atención de siempre.
No hay un ojo. Hay una secuencia más larga.
Y ojo con la confusión que cuesta dinero en reuniones de producto: que un modelo acepte imágenes no significa que las genere. Claude entiende imágenes, no las produce ni las edita. Gemini y la familia GPT sí generan, con endpoints y precios propios. Cuando alguien proponga "usar IA multimodal", pregunta si habla de entrada o de salida.
El código: mandar una imagen de verdad
Así se envía una imagen a Claude con el SDK oficial de TypeScript. Fíjate en el orden: la imagen antes del texto, porque la propia documentación de Anthropic recomienda esa estructura.
import Anthropic from "@anthropic-ai/sdk";
import { readFile } from "node:fs/promises";
const anthropic = new Anthropic(); // lee ANTHROPIC_API_KEY del entorno
const imageData = (await readFile("factura.jpg")).toString("base64");
const message = await anthropic.messages.create({
model: "claude-opus-5",
max_tokens: 16000, // el thinking va dentro de este tope: no lo dejes corto
messages: [
{
role: "user",
content: [
{
type: "image",
source: {
type: "base64",
media_type: "image/jpeg",
data: imageData,
},
},
{
type: "text",
text: "Extrae total, fecha y NIF. Devuelve JSON. Si un campo no es legible, null.",
},
],
},
],
});
console.log(message.usage.input_tokens); // aquí está la factura de verdad
Si la imagen ya vive en una URL pública, te ahorras el base64:
// sustituye el bloque de imagen del array content por este
const imageBlock: Anthropic.ImageBlockParam = {
type: "image",
source: { type: "url", url: "https://ejemplo.com/factura.jpg" },
};
Loguea usage.input_tokens desde el primer día. Es la diferencia entre una demo bonita y saber lo que te va a costar en producción.
Y ese null del prompt no es adorno: cuando el modelo te devuelve JSON extraído de un píxel borroso, necesitas un esquema que valide antes de que ese dato toque tu base de datos. Es el patrón que trabajo en el curso de Zod: el modelo propone, el schema dispone.
Cuánto cuesta una imagen en un modelo multimodal
Una imagen cuesta ⌈ancho / 28⌉ × ⌈alto / 28⌉ visual tokens en la API de Claude. Es aritmética pública y simple, y aun así aquí es donde se tuercen la mayoría de los proyectos multimodales: nadie hace la cuenta antes.
Los modelos de Claude 4.7 en adelante están en el tier de alta resolución (borde largo máximo 2576 px, tope de 4.784 visual tokens); los anteriores, en el estándar (1568 px, 1.568 tokens). Si te pasas, la imagen se reescala antes de procesarse.
Estas son las cifras que publica la documentación oficial de visión de Anthropic:
| Imagen | Tier estándar | Tier alta resolución |
|---|---|---|
| 200×200 px | 64 tokens | 64 tokens |
| 1000×1000 px | 1.296 tokens | 1.296 tokens |
| 1920×1080 px | 1.560 tokens (reescalada a 1456×819) | 2.691 tokens |
| 3840×2160 px (4K) | 1.560 tokens (reescalada) | 4.784 tokens (reescalada a 2576×1449) |
Traduce eso a dinero. Con Opus 5 a 5 $ por millón de tokens de entrada (precios de julio de 2026), mil capturas de 1000×1000 salen por unos 6,48 $ y mil capturas en 4K por unos 23,92 $. La cuenta la puedes rehacer tú: 1.296 × 5 / 1.000.000 × 1.000.
Parece barato hasta que lo multiplicas por un agente que itera catorce veces sobre la misma pantalla.
Con audio pasa lo mismo en otra escala. Gemini documenta 32 tokens por segundo, o sea 1.920 tokens por minuto. Una reunión de una hora son unos 115.000 tokens de entrada antes de que el modelo escriba una sola palabra.
Tres consecuencias prácticas:
- Redimensiona antes de subir. Mandar un 4K cuando el texto se lee perfectamente a 1200 px es tirar tokens y latencia a la basura.
- En conversaciones de varios turnos, usa la Files API. Con base64 el payload entero viaja otra vez en cada turno, porque el historial se reenvía completo. Con
file_idsubes una vez y referencias. Ojo: hoy va poranthropic.beta.files.uploady hay que pasarbetas: ["files-api-2025-04-14"]. - La imagen infla el prompt, no la respuesta. Ese coste es todo de entrada y el modelo lo digiere antes del primer token. La latencia sube aunque respondas tres líneas.
Dónde falla un modelo multimodal (y falla más de lo que crees)
Un modelo multimodal alucina con imágenes por el mismo motivo por el que la IA se inventa cosas con texto: no hay un módulo de verdad, hay una distribución de probabilidad. La diferencia es que con una imagen mala el modelo tiene menos señal y más margen para rellenar con lo plausible.
Mi dashboard fue justo eso. Cifras pequeñas, reescaladas, con poco contraste. El modelo generó el número que estadísticamente encajaba en ese hueco.
La documentación de Anthropic reconoce los límites sin maquillaje. Con imágenes de baja calidad, rotadas o de menos de 200 píxeles, alucina. Los conteos de objetos son aproximados. Las coordenadas, también. Y no puede determinar si una imagen fue generada por IA: si se lo preguntas, se inventa la respuesta.
Léelo otra vez: el conteo es aproximado. Si tu caso de uso es "cuántos palés hay en esta foto" y tu negocio depende de esa cifra, tienes un problema de arquitectura, no de prompt.
Sobre el OCR: un modelo multimodal entiende un documento con layout raro, tablas torcidas o manuscritos mucho mejor que Tesseract. Pero un OCR clásico es determinista y trazable. El modelo puede darte dos respuestas distintas para la misma imagen, y si le pides coordenadas te las da aproximadas, nunca como una región verificable contra el original. En un pipeline de compliance eso es inaceptable.
| Modelo multimodal | OCR clásico (Tesseract, Textract) | |
|---|---|---|
| Layout variable, manuscritos, fotos malas | Muy bueno | Malo |
| Misma imagen → misma salida | No garantizado | Sí |
| Trazabilidad de dónde salió el dato | No la da | Sí, con bounding boxes |
| Coste | Por visual token, escala con la resolución | Plano o por página |
| Entiende el contenido ("¿este ticket es de comida?") | Sí | No |
| Apto para compliance sin revisión humana | No | Sí |
Cuándo usar un modelo multimodal y cuándo es un martillo caro
Mi regla, después de comerme varias facturas de API sin necesidad:
Si el dato ya existe en forma estructurada, no le mandes la foto. Si tienes el PDF con capa de texto, extrae el texto. Si tienes la API del dashboard, llama a la API. Mandar una captura de algo que podías consultar en JSON es la forma más cara de leer un número.
Usa multimodal cuando la información vive en la disposición visual y no en el contenido. Un ticket arrugado fotografiado de noche. Un diagrama en una pizarra. El screenshot de una UI rota que un usuario manda por soporte. Ahí la alternativa no es un parser peor: es que no hay alternativa.
Y vigílalo dentro del bucle agéntico. Si montas un agente que navega e interpreta pantallas, cada iteración multiplica el coste visual. Esa distinción entre IA generativa e IA agéntica importa mucho más cuando cada paso arrastra 2.700 tokens de imagen.
Y si lo que necesitas es buscar entre miles de imágenes en vez de razonar sobre una, ya no quieres un modelo generativo: quieres embeddings multimodales e índice vectorial. Lo tienes montado paso a paso en el pipeline multimodal con Gemini Embedding 2.
La decisión que va antes —si tu problema es de búsqueda, de RAG o de fine-tuning— la desmenucé aquí.
Lo que puedes hacer hoy
Coge la funcionalidad multimodal que tengas en marcha o en el backlog y haz una sola cosa: calcula sus visual tokens con la fórmula, multiplícalos por tu volumen mensual real y compáralo con lo que cuesta resolverlo sin imagen.
En más casos de los que esperas descubrirás que ibas a pagar por interpretar un pantallazo de un dato que ya tenías en una tabla. En el resto tendrás el número exacto para defender el proyecto delante de quien firma.
Los modelos multimodales no son magia ni son un timo. Son un canal de entrada más, con su precio por parche y su margen de error. Trátalos como lo que son: una dependencia cara. Mídela antes de casarte con ella.
Cómo encaja esto en un producto completo —qué resuelve el modelo y qué resuelve código normal— lo trabajo de principio a fin en Construye con IA. Y si prefieres discutirlo con gente que está construyendo lo mismo esta semana, estamos en Dominicode Labs.
Preguntas frecuentes
¿Qué es un modelo multimodal en una frase?
Un modelo que acepta varios tipos de entrada —texto, imagen, audio, vídeo— porque los convierte todos a vectores del mismo espacio antes de procesarlos. En la práctica, para el desarrollador significa una sola cosa: tu imagen entra en el prompt como tokens, cuesta como tokens y se factura como tokens.
¿Un modelo multimodal "ve" la imagen como una persona?
No. Trocea el bitmap en parches, convierte cada parche en un vector y los intercala con los tokens de tu prompt. No hay percepción: hay una secuencia de números sobre la que se aplica atención. Por eso describe con precisión una escena compleja y a la vez falla contando cuatro objetos.
¿Cuántos tokens cuesta enviar una imagen?
Depende de la resolución y del proveedor. En la API de Claude son ⌈ancho / 28⌉ × ⌈alto / 28⌉ visual tokens, con reescalado automático si superas el límite del modelo: 1000×1000 px son 1.296 tokens y un 4K llega al tope de 4.784 en el tier de alta resolución. Son cifras aproximadas de la documentación oficial, así que loguea usage.input_tokens en vez de fiarte de una estimación.
¿Es mejor un modelo multimodal que un OCR clásico?
Para documentos con layout variable, manuscritos o fotos malas, casi siempre sí. Para pipelines que necesitan determinismo, trazabilidad y coste plano, no. Muchos sistemas serios usan los dos, con el modelo actuando solo sobre lo que el OCR no resuelve.
¿Los modelos multimodales también generan imágenes?
No todos. Aceptar imágenes como entrada y producirlas como salida son capacidades distintas. Claude entiende imágenes pero no las genera ni las edita, según su propia documentación. Gemini y la familia GPT sí tienen generación, con endpoints y precios propios. Confirma cuál de las dos necesitas antes de planificar la feature.
Por Bezael Pérez — Developer senior con más de 15 años de experiencia y fundador de Dominicode.
