---
title: "Procesamiento por lotes con LLM sin Batch API | BroadRouter"
description: "Procese de 10,000 a 1,000,000 de prompts con una API de chat completions sin Batch API: concurrencia, ritmo, reintentos, checkpoints y cálculo de tiempos."
url: https://broadrouter.com/es/blog/llm-batch-processing-without-batch-api/
lang: es
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traducido del inglés con ayuda de IA. [Lea el original en inglés](https://broadrouter.com/blog/llm-batch-processing-without-batch-api/) (actualizado el 2026-11-16).

# Procesamiento por lotes con LLM sin Batch API: un runner reanudable

Por el equipo de BroadNet Inference · 8 min de lectura · Publicado 2026-11-15 · Actualizado 2026-11-16

Sin Batch API, ejecute el trabajo usted mismo: lea los elementos de un archivo JSONL, limite las solicitudes en curso al tope de la clave, espacie los inicios por debajo del límite por minuto, reintente los 429 y 5xx con backoff acotado y anexe cada resultado con su ID. Al reiniciar, omita los ID terminados. Normalmente es el rate limit, no el modelo, lo que fija la hora de finalización.

## Puntos clave

-   BroadNet Inference solo documenta chat completions y transcripciones. No hay Batch API ni descuento por lotes, así que un trabajo masivo es un bucle de solicitudes normales.
-   Tiempo total = elementos ÷ la más lenta de dos tasas: límite de solicitudes en curso ÷ latencia, o solicitudes por minuto. Una clave de pago por uso permite 4 en curso y 30 por minuto, así que con un elemento por solicitud el máximo es 43,200 al día.
-   Escriba una línea de resultado por elemento, con su ID, y vacíela al disco. Esa línea es el checkpoint: una caída cuesta como mucho las solicitudes que estaban en curso.
-   Una sesión de plan ejecuta una solicitud a la vez. Su rendimiento es 86,400 ÷ sus segundos medidos por elemento, al día, por sesión.
-   Si el trabajo puede esperar un día y un descuento del 50 % por lotes importa, las Batch API de OpenAI y Anthropic pueden ser la herramienta más barata. Calcule el costo de ambas.

**En esta página**

1.  ¿BroadNet Inference tiene Batch API?
2.  ¿Cuánto tardará el trabajo?
3.  ¿Cómo es un runner reanudable?
4.  ¿Por qué un pool de workers y no asyncio.gather?
5.  ¿Cómo se mantienen seguros los reintentos?
6.  ¿Cómo funciona el checkpointing?
7.  ¿Cuánto cuesta: pago por uso o una sesión de plan?
8.  Dónde encaja BroadNet Inference

Algunos trabajos con LLM no son chats. Tiene 50,000 tickets de soporte que etiquetar, 200,000 descripciones de productos que traducir o un millón de reseñas que puntuar. Proveedores como OpenAI y Anthropic venden una [Batch API](https://broadrouter.com/es/glossary/batch-api/) para esto. Muchas APIs compatibles con OpenAI, entre ellas BroadNet Inference, no la tienen. Este artículo muestra cómo ejecutar el trabajo usted mismo: calcular cuánto tardará, escribir un runner que respete los límites y hacer que sea seguro detenerlo y reiniciarlo.

BroadRouter es el sitio de BroadNet, así que los ejemplos numéricos usan los límites publicados por BroadNet. El método funciona con cualquier API de chat completions; sustituya las cifras por las de su proveedor.

## ¿BroadNet Inference tiene Batch API?

No. La [referencia de la API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-llm-batch-processing-without-batch-api&utm_content=body), consultada el 15 de noviembre de 2026, documenta `POST /v1/chat/completions`, `POST /v1/audio/transcriptions` y `GET /v1/models` (una lista de modelos), además de endpoints de cuenta en `/portal/`. No hay endpoint de lotes ni de carga de archivos, ni descuento por lotes. Un trabajo masivo es un bucle de solicitudes normales.

Esto es lo que ofrece una Batch API gestionada, para que sepa qué está reconstruyendo:

|  | Batch API de OpenAI | Message Batches de Anthropic | Su propio runner |
| --- | --- | --- | --- |
| Precio | 50 % menos que en modo síncrono | 50 % de descuento | Precio normal |
| Tiempo de entrega | En 24 horas | La mayoría en 1 hora; caduca a las 24 | Lo fijan sus rate limits |
| Tamaño por lote | 50,000 solicitudes o 200 MB | 100,000 solicitudes o 256 MB | Cualquier tamaño |
| Rate limits | Separados de los límites por modelo | Aplican a las solicitudes en cola | Los límites de su clave |
| Orden de resultados | Puede variar; empareje por `custom_id` | Empareje por `custom_id` | Usted asocia los resultados por ID |

Hay dos lecciones que se trasladan. Ambos proveedores le obligan a etiquetar cada solicitud con un ID, porque los resultados no vuelven en orden. Ninguno promete una respuesta en segundos. Su runner debe funcionar igual: ID en todo y un plan medido en horas.

Si un descuento del 50 % importa más que el tiempo de entrega, y los modelos que necesita están ahí, una Batch API gestionada puede ser la herramienta más barata. Calcule el costo de ambas opciones con la [calculadora de costos de API de LLM](https://broadrouter.com/tools/llm-api-cost-calculator/) antes de construir.

## ¿Cuánto tardará el trabajo?

Calcúlelo antes de escribir código. Dos límites restringen el rendimiento, y manda el más lento:

-   **Límite de solicitudes en curso ÷ latencia.** Con 4 solicitudes en curso y 2 segundos por solicitud, puede terminar 2 por segundo.
-   **Solicitudes por minuto.** A 30 por minuto, puede iniciar 0.5 por segundo, por rápido que sea el modelo.

Una clave de [pago por uso](https://broadrouter.com/es/glossary/pay-as-you-go/) de BroadNet permite 4 solicitudes en curso y 30 por minuto. Con los valores de la referencia de la API cuando la consultamos (30 por minuto y 4 en curso, 2026-11-15), el [rate limit](https://broadrouter.com/es/glossary/rate-limit/) es el que manda salvo que cada solicitud tarde más de 8 segundos, y la tabla siguiente usa 30 por minuto:

| Elementos | Un elemento por solicitud | 20 elementos por solicitud |
| --- | --- | --- |
| 10,000 | 5.6 horas | 17 minutos |
| 100,000 | 2.3 días | 2.8 horas |
| 1,000,000 | 23 días | 28 horas |

A 30 solicitudes por minuto, una clave hace 1,800 solicitudes por hora, o 43,200 al día. Los reintentos también cuentan: cada 429 que provoque consume un hueco.

La segunda columna es la palanca más grande. Los elementos cortos, como reseñas o asuntos de tickets, pueden ir de 10 a 50 por solicitud como lista numerada, con un array JSON de vuelta. Compruebe que el array tenga una entrada por elemento y que cada una lleve su número. El [artículo de clasificación de texto en árabe](https://broadrouter.com/es/blog/arabic-text-classification-llm/) muestra el patrón. Los elementos largos no se agrupan: cada solicitud tiene que caber en la [ventana de contexto](https://broadrouter.com/es/glossary/context-window/) del modelo, y la calidad puede bajar a medida que crece la lista. Pruebe la agrupación con 200 elementos antes de confiar en ella.

No reparta un trabajo entre varias claves para superar un límite por clave sin preguntar. La [Política de Uso Aceptable](https://www.broadnet.ai/aup) de BroadNet prohíbe eludir límites de tasa, de concurrencia o de presupuesto. Si necesita más, pregunte a BroadNet o use sesiones de plan, más abajo. El [planificador de trabajos por lotes](https://broadrouter.com/tools/llm-batch-job-planner/) hace este cálculo para su número de elementos, su latencia y sus límites.

## ¿Cómo es un runner reanudable?

Este runner lee `items.jsonl` (un objeto `{"id", "text"}` por línea) y anexa una línea de resultado por elemento a `results.jsonl`. Solo necesita el SDK de OpenAI para Python.

```python
import asyncio, json, os, random, time
from openai import AsyncOpenAI, APIStatusError, APIConnectionError, APITimeoutError

client = AsyncOpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
                     api_key=os.environ["BROADNET_API_KEY"],
                     max_retries=0,        # we retry ourselves, with a cap we can see
                     timeout=120)
MODEL = os.environ.get("MODEL", "broadnet/deepseek-v4.1-flash")
IN_FLIGHT = int(os.environ.get("IN_FLIGHT", "4"))     # PAYG key: 4 in flight. Plan: 1 per session.
RPM = int(os.environ.get("RPM", "30"))                # PAYG key: 30 requests a minute
MAX_ATTEMPTS = 6

class Pacer:
    """Spaces request starts at least 60/RPM seconds apart, across all workers."""
    def __init__(self, rpm):
        self.gap, self.next, self.lock = 60 / rpm, 0.0, asyncio.Lock()
    async def wait(self):
        async with self.lock:
            now = time.monotonic()
            delay = max(0.0, self.next - now)
            self.next = max(now, self.next) + self.gap
        await asyncio.sleep(delay)

def retryable(e):
    if isinstance(e, (APIConnectionError, APITimeoutError)):
        return True
    return isinstance(e, APIStatusError) and e.status_code in (429, 500, 502, 503, 504)

async def call(item, pacer):
    for attempt in range(MAX_ATTEMPTS):
        await pacer.wait()                          # every attempt counts against the rate limit
        try:
            r = await client.chat.completions.create(
                model=MODEL, max_tokens=1500, reasoning_effort="low",
                messages=[{"role": "system", "content": "Classify the review as positive, negative or mixed. Reply with one word."},
                          {"role": "user", "content": item["text"]}])
            c = r.choices[0]
            return {"id": item["id"], "ok": True, "finish_reason": c.finish_reason,
                    "output": c.message.content, "usage": r.usage.model_dump() if r.usage else None}
        except Exception as e:
            if not retryable(e) or attempt == MAX_ATTEMPTS - 1:
                return {"id": item["id"], "ok": False, "error": repr(e)[:300]}
            await asyncio.sleep(random.uniform(0, min(60, 2 ** attempt)))   # full jitter, capped

async def run(in_path, out_path):
    done = set()
    if os.path.exists(out_path):                    # resume: skip ids that already succeeded
        with open(out_path) as f:
            done = {json.loads(l)["id"] for l in f if l.strip() and json.loads(l).get("ok")}
    todo = [it for it in map(json.loads, open(in_path)) if it["id"] not in done]
    print(f"{len(done)} done, {len(todo)} to go")
    pacer, queue = Pacer(RPM), asyncio.Queue()
    for it in todo:
        queue.put_nowait(it)
    with open(out_path, "a") as out:
        async def worker():
            while True:
                try:
                    it = queue.get_nowait()
                except asyncio.QueueEmpty:
                    return
                res = await call(it, pacer)
                out.write(json.dumps(res, ensure_ascii=False) + "\n")
                out.flush()                         # one line per finished item = the checkpoint
        await asyncio.gather(*(worker() for _ in range(IN_FLIGHT)))

if __name__ == "__main__":
    import sys
    asyncio.run(run(sys.argv[1], sys.argv[2]))
```

Ejecútelo con `python batch_run.py items.jsonl results.jsonl`. Probamos exactamente este archivo contra un servidor simulado local que devolvía 429 aleatorios (8 %) y 500 (5 %) y rechazaba cualquier cosa por encima de 4 en curso o 30 inicios por minuto. 25 elementos terminaron en 55 segundos con 28 solicitudes (3 reintentos), y nunca hubo más de 30 inicios en ninguna ventana de 60 segundos. Con el límite del simulador elevado a 300 por minuto para ahorrar tiempo, una ejecución de 120 elementos interrumpida a los 10 segundos se reanudó desde 39 resultados guardados y terminó con 120 ID únicos y sin duplicados.

## ¿Por qué un pool de workers y no asyncio.gather?

La [guía del error 429](https://broadrouter.com/es/blog/handle-llm-api-429-rate-limits/) usa un semáforo alrededor de `asyncio.gather`. Eso está bien para unos cientos de llamadas. Para un trabajo grande, es mejor un pool fijo de workers que toman elementos de una cola:

-   **Memoria.** `gather` crea una tarea por elemento desde el principio. Un pool solo mantiene los elementos en curso.
-   **La concurrencia es el tamaño del pool.** Cuatro workers nunca pueden tener cinco solicitudes abiertas.
-   **Los resultados se escriben en disco** a medida que terminan, en cualquier orden, asociados por ID.

El `Pacer` se ocupa del segundo límite. Un semáforo por sí solo evita superar 4 en curso, pero si las solicitudes tardan un segundo, cuatro workers iniciarían 240 por minuto y recibirían 429 en la mayoría. El pacer espacia los inicios 2 segundos entre todos los workers, reintentos incluidos.

## ¿Cómo se mantienen seguros los reintentos?

Reintente solo lo que puede funcionar en un segundo intento:

| Respuesta | Acción |
| --- | --- |
| 429 | Espere y reintente; la documentación de BroadNet dice “use response details and bounded backoff” (Traducción: use los detalles de la respuesta y un backoff acotado) |
| 500, 502, 503, 504, timeouts, conexiones caídas | Reintente con backoff exponencial acotado |
| 400, 422 | Corrija la solicitud; reintentar envía el mismo error |
| 401, 402, 403 | Detenga el trabajo; la clave, el saldo o la política requieren atención |
| 413 | Acorte el elemento |

El runner desactiva los reintentos propios del SDK (`max_retries=0`) para que haya exactamente una política de reintentos, con un tope visible. El backoff es [exponencial](https://broadrouter.com/es/glossary/exponential-backoff/) con full jitter, con un tope de 60 segundos, para que los workers que fallaron juntos no reintenten juntos. Tras seis intentos, el elemento se escribe con `"ok": false` y el trabajo sigue. Un elemento defectuoso nunca detiene un millón.

Una llamada al modelo no tiene efectos secundarios, así que aquí la entrega es “al menos una vez”: si el proceso muere a mitad de una solicitud, ese elemento se envía de nuevo al reiniciar, y lo paga dos veces. Ese es el único desperdicio. Si el trabajo también escribe en otro sistema, como tickets o correos, haga esa escritura [idempotente](https://broadrouter.com/es/glossary/idempotency-key/) por ID de elemento y hágala en una pasada aparte sobre `results.jsonl`. El [artículo sobre agentes de larga duración](https://broadrouter.com/es/blog/long-running-agents-timeouts-retries/) trata a fondo los efectos secundarios idempotentes.

## ¿Cómo funciona el checkpointing?

El archivo de salida es el checkpoint. Cada elemento terminado es una línea vaciada a disco, así que tras una caída, un despliegue o un Ctrl-C, la siguiente ejecución lee el archivo, reúne los ID con `"ok": true` y encola solo el resto. Los elementos que fallaron antes se reintentan en la siguiente ejecución y su nueva línea se anexa. Al leer los resultados, quédese con la última línea de cada ID.

Tres hábitos hacen que esto aguante durante días:

1.  **ID estables.** Use una clave de base de datos o un hash de la entrada, nunca un número de línea que cambia cuando cambia el archivo de entrada.
2.  **Revise `finish_reason`.** Una respuesta cortada en `max_tokens` es `"ok": true` pero inútil. DeepSeek V4.1 Flash, GLM 5.3 y Qwen3.8 27B razonan antes de responder, y [el razonamiento cuenta dentro de max\_tokens](https://broadrouter.com/es/guides/reasoning-tokens-empty-response/). El runner fija `reasoning_effort="low"`, que BroadNet documenta, y deja 1,500 tokens.
3.  **Registre el uso en cada línea.** Sumar `usage` de `results.jsonl` le da la factura real de tokens para compararla con su estimación.

## ¿Cuánto cuesta: pago por uso o una sesión de plan?

En pago por uso, el costo son los tokens. Tome 100,000 reseñas, un prompt de sistema de 150 tokens, una reseña de 150 tokens y 100 tokens de salida con razonamiento bajo. Eso son 30 millones de tokens de entrada y 10 millones de salida. En [DeepSeek V4.1 Flash](https://broadrouter.com/es/models/deepseek-v4.1-flash/) cuesta 30 × $0.175 + 10 × $0.52. Mantenga el prompt de sistema al principio e idéntico byte a byte, y sus 15 millones de tokens pueden cobrarse a la tarifa de [entrada en caché](https://broadrouter.com/es/blog/cached-input-tokens-explained/) de $0.0055 por 1M cuando la caché acierta. Sus líneas de `usage` muestran con qué frecuencia lo hizo.

En un plan, los tokens son gratis y el costo es el tiempo. Una sesión de plan de DeepSeek V4.1 Flash “runs one request at a time” (Traducción: ejecuta una solicitud a la vez), así que fije `IN_FLIGHT=1` por sesión. El rendimiento por sesión es 86,400 ÷ segundos por elemento, al día. BroadNet indica una velocidad típica de unos 100 tokens por segundo, pero su latencia depende de la longitud del prompt y del razonamiento, así que mídala con 50 elementos. Si mide 3 segundos por elemento, una sesión procesa 28,800 al día:

| Trabajo | Sesiones | Tiempo a 3 s/elemento | Plan |
| --- | --- | --- | --- |
| 100,000 elementos | 1 | Unos 3.5 días | Una semana de Órbita (Orbit), $15 por sesión |
| 100,000 elementos | 4 | Unas 21 horas | Cuatro semanas de Órbita, una por sesión; o unas 21 horas de Meteoro (Meteor) por sesión, a $1 cada una |
| 1,000,000 elementos | 6 | Unos 6 días | Seis semanas de Órbita |

Los planes se ofrecen “best effort under fair use” (Traducción: con el mejor esfuerzo bajo uso justo), y BroadNet no publica un límite de solicitudes por minuto para las claves de plan; su cuenta muestra los límites que aplican. Configure `RPM` a partir de ellos, no a ojo. La [guía de planificación de sesiones](https://broadrouter.com/es/guides/unlimited-llm-api-sessions/) explica cómo repartir las sesiones entre claves.

## Dónde encaja BroadNet Inference

BroadNet Inference no tiene Batch API, así que encaja en trabajos masivos cuando usted prefiere controlar el runner y pagar precios normales por token, o fijar el costo con sesiones de plan de DeepSeek V4.1 Flash. Para trabajos pequeños con presupuesto ajustado, [Gemma 4 VL 26B](https://broadrouter.com/es/models/gemma-4-vl-26b/), a $0.10 de entrada y $0.22 de salida por 1M, funciona con el crédito inicial de $5. Los prompts y las salidas no se conservan después de cada solicitud. Si su trabajo puede esperar un día y los modelos que necesita están en un proveedor con un descuento por lotes del 50 %, eso puede costar menos; compare antes de comprometerse. Los planes y límites están en [inference.broadnet.ai/plans](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-llm-batch-processing-without-batch-api&utm_content=body).

Herramientas gratuitas sobre este tema (en inglés)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Herramientas gratuitas (en inglés)](https://broadrouter.com/tools/)

## Términos de este artículo

[Token](https://broadrouter.com/es/glossary/token/)

Un token es la unidad de texto que un modelo de lenguaje lee y escribe: una palabra, parte de una palabra, un signo de puntuación o una secuencia de bytes producida por el tokenizador del modelo. Las APIs de LLM cuentan, limitan y normalmente facturan el uso en tokens.

[Límite de frecuencia (rate limit)](https://broadrouter.com/es/glossary/rate-limit/)

Un límite de frecuencia (rate limit) es un tope que una API impone a cuánto puede usarla un cliente en un periodo, como solicitudes por minuto o tokens por minuto. Las solicitudes que lo superan se rechazan, normalmente con HTTP 429 Too Many Requests, hasta que el uso vuelve a quedar por debajo.

[Concurrencia (concurrency)](https://broadrouter.com/es/glossary/concurrency/)

La concurrencia es el número de solicitudes que un cliente tiene en curso al mismo tiempo. Las APIs de LLM suelen limitarla por clave o por plan, aparte de las solicitudes por minuto, porque cada solicitud abierta ocupa capacidad de GPU hasta que su respuesta termina.

[Pago por uso (pay-as-you-go)](https://broadrouter.com/es/glossary/pay-as-you-go/)

El pago por uso es un modelo de precios en el que usted paga solo lo que usa, medido por unidades como tokens, solicitudes o minutos de audio, sin suscripción ni compromiso mínimo. La mayoría de las APIs de LLM cobran así, desde un saldo prepagado o con una factura periódica.

[Batch API (API de procesamiento por lotes)](https://broadrouter.com/es/glossary/batch-api/)

Una Batch API es un endpoint asíncrono de LLM que acepta muchas solicitudes a la vez, normalmente en un archivo, las procesa dentro de un plazo fijado en lugar de inmediatamente y devuelve los resultados juntos. Proveedores como OpenAI y Anthropic cobran las solicitudes por lotes con descuento respecto de sus APIs estándar.

[Backoff exponencial (exponential backoff)](https://broadrouter.com/es/glossary/exponential-backoff/)

El backoff exponencial es una estrategia de reintento en la que el cliente espera más tiempo tras cada intento fallido, normalmente duplicando la espera hasta un tope, antes de volver a intentarlo. Añadir jitter aleatorio a cada espera dispersa los reintentos de muchos clientes para que no lleguen al servidor en el mismo instante.

[Latencia (latency)](https://broadrouter.com/es/glossary/latency/)

La latencia, en una API de modelos de lenguaje, es el tiempo que tarda una solicitud desde que se envía hasta que se recibe el último token de salida. Es la suma del tiempo hasta el primer token y el tiempo de generación, y suele reportarse en percentiles como p50 y p95, no como promedio.

[API de Chat Completions](https://broadrouter.com/es/glossary/chat-completions-api/)

La API de Chat Completions es el endpoint HTTP de OpenAI, POST /v1/chat/completions, que recibe un nombre de modelo y una lista de mensajes etiquetados con su rol y devuelve el siguiente mensaje del modelo. Su forma de solicitud y respuesta se convirtió en el formato común que reutilizan los proveedores y SDKs compatibles con OpenAI.

## Preguntas frecuentes

### ¿BroadNet Inference tiene Batch API?

No. Su referencia de API, consultada el 15 de noviembre de 2026, documenta POST /v1/chat/completions, POST /v1/audio/transcriptions y GET /v1/models, sin endpoint de lotes ni de carga de archivos, y sin descuento por lotes. Ejecute los trabajos masivos como solicitudes normales dentro de los límites de su clave.

### ¿Cómo proceso 100,000 prompts con una API de LLM?

Ponga los elementos en un archivo JSONL, cada uno con un ID. Ejecute un número fijo de workers igual al límite de solicitudes en curso de la clave, espacie los inicios por debajo del límite por minuto, reintente los 429 y 5xx con backoff acotado y anexe cada resultado a un archivo de salida con su ID para que el trabajo pueda reanudarse.

### ¿Cuánto tarda un lote de un millón de solicitudes?

Divida los elementos entre su tasa real. A 30 solicitudes por minuto y un elemento por solicitud, una clave procesa 43,200 al día, así que un millón tarda unos 23 días. Agrupar 20 elementos cortos por solicitud lo reduce a unas 28 horas, si el modelo maneja bien el prompt más largo.

### ¿Uso asyncio.gather o un pool de workers para llamadas por lotes a un LLM?

Para decenas de miles de elementos, use un pool fijo de workers que tomen elementos de una cola. gather con un semáforo sirve para trabajos pequeños, pero crea todas las tareas de entrada y complica la reanudación y el seguimiento del progreso.

### ¿Puedo usar varias claves de API para ir más rápido?

Consulte primero. La Política de Uso Aceptable de BroadNet prohíbe eludir los límites de tasa o de concurrencia, así que pregunte a BroadNet antes de repartir un trabajo entre varias claves para superar un límite por clave. Agrupar más elementos por solicitud y las sesiones de plan son las formas documentadas de aumentar el rendimiento.

### ¿Un plan de tarifa plana sirve para trabajos por lotes?

Puede servir, con DeepSeek V4.1 Flash. Una sesión ejecuta una solicitud a la vez sin medidor de tokens, así que el costo es fijo y la cuestión es el tiempo. Mida los segundos por elemento y compre suficientes sesiones para terminar dentro del periodo.

## Siga leyendo

-   [Cómo manejar el 429 de una API de LLM: backoff, jitter y limitadores](https://broadrouter.com/es/blog/handle-llm-api-429-rate-limits/)
-   [Agentes de larga duración: timeouts, reintentos y checkpoints sólidos](https://broadrouter.com/es/blog/long-running-agents-timeouts-retries/)
-   [Clasificar texto en árabe con un LLM: sentimiento, intención, triaje](https://broadrouter.com/es/blog/arabic-text-classification-llm/)
-   [Cómo ejecutar agentes de programación en paralelo con tarifa plana](https://broadrouter.com/es/blog/run-parallel-coding-agents-flat-rate/)
-   [Un plan LLM semanal para proyectos cortos: Órbita frente a hora y mes](https://broadrouter.com/es/blog/weekly-llm-plan-short-projects/)
-   [Cómo estimar el costo de una API de LLM antes de lanzar una función](https://broadrouter.com/es/blog/estimate-llm-api-cost-before-launch/)
-   [El hardware GPU de BroadNet y cómo sirve los modelos, según BroadNet](https://broadrouter.com/es/blog/broadnet-gpu-fleet-and-serving/)
-   [Caché de respuestas de APIs de LLM para reducir costos en Python](https://broadrouter.com/es/blog/cache-llm-responses-cut-cost/)
-   [Guía: Códigos de error de BroadNet Inference y cuándo reintentar](https://broadrouter.com/es/guides/errors-and-retries/)
-   [Guía: Usar el SDK de OpenAI para Python con BroadNet Inference](https://broadrouter.com/es/guides/openai-python-sdk/)
-   [Guía: Cómo funcionan los planes de API de LLM ilimitada para agentes](https://broadrouter.com/es/guides/unlimited-llm-api-sessions/)

Pruébelo con su carga de trabajo real. Las cuentas nuevas empiezan con USD 5 de crédito para Gemma y transcripción. DeepSeek, GLM y Qwen3.8 requieren una recarga.

[Comenzar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-llm-batch-processing-without-batch-api&utm_content=page-cta) ·

**Fuentes**

-   [Referencia de la API de BroadNet Inference: endpoints, límites de pago por uso (30 por minuto, 4 en curso), límites de claves por hora, guía de reintentos para 429 y 5xx, reasoning\_effort (consultado el 2026-11-15) (en inglés)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [Página de planes de BroadNet Inference: una solicitud a la vez por sesión, velocidad típica, precios de los planes (consultado el 2026-11-15)](https://inference.broadnet.ai/es/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [Política de Uso Aceptable de BroadNet, secciones 3 y 4: no eludir límites de tasa o concurrencia; planes con el mejor esfuerzo bajo uso justo (consultado el 2026-11-15)](https://www.broadnet.ai/es/aup)
-   [Guía de la Batch API de OpenAI: 50 % de descuento, ventana de 24 h, 50,000 solicitudes o 200 MB por lote, el orden de salida puede variar, custom\_id (consultado el 2026-11-15)](https://developers.openai.com/api/docs/guides/batch)
-   [Documentación de Message Batches API de Anthropic: 50 % de descuento, 100,000 solicitudes o 256 MB, la mayoría de los lotes en 1 hora, caducan a las 24 horas (consultado el 2026-11-15)](https://platform.claude.com/docs/en/build-with-claude/batch-processing)
