---
title: "Endpoint privado de LLM: o que definir antes | BroadRouter"
description: "O que definir antes de pedir um endpoint privado de LLM: carga de trabalho, tokens por segundo, concorrência, contexto, região, licença e orçamento, e como testá-lo."
url: https://broadrouter.com/pt/blog/private-endpoint-planning/
lang: pt-BR
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/private-endpoint-planning/) (atualizado em 2026-11-15).

# Um endpoint privado começa com uma carga de trabalho clara

Pela equipe da BroadNet Inference · 7 min de leitura · Publicado em 2026-11-15

Antes de pedir um endpoint privado, registre a carga de trabalho: requisições por dia e no pico, tokens de entrada e saída, a concorrência que isso implica, o contexto necessário, a região de processamento, o modelo e sua licença, e um orçamento. Combine região e limites por escrito e faça um smoke test no endpoint recebido antes de usar dados reais.

## Pontos principais

-   Um pedido de capacidade vale o que valem seus números: requisições por segundo no pico, tokens de entrada e saída e a latência que você aceita.
-   A concorrência sai da lei de Little: requisições em andamento = taxa de chegada × tempo por requisição. Meça antes o tempo por requisição em um teste.
-   A BroadNet descreve publicamente endpoints privados como capacidade de GPU reservada com preço conforme o seu tráfego, com chave, limites e região próprios, acessada por um ID de modelo privado. Todo o resto é combinado com a BroadNet.
-   Os Termos da BroadNet dizem que o autoatendimento não tem compromisso de disponibilidade e que endpoints privados e capacidade reservada seguem um acordo escrito separado.
-   Teste o endpoint recebido antes da produção: ID do modelo, streaming, a concorrência combinada e o erro para um ID de modelo errado.

**Nesta página**

1.  Quando um endpoint privado faz sentido?
2.  O que definir sobre a carga de trabalho?
3.  Como transformar volume em tokens por segundo e concorrência?
4.  E região, residência e limites?
5.  Qual modelo, e com qual licença?
6.  Como definir um orçamento?
7.  Como enviar a consulta?
8.  Como validar o endpoint recebido?
9.  Onde a BroadNet Inference se encaixa

“Precisamos de um endpoint dedicado” é o começo de uma conversa, não uma especificação. O provedor não consegue dimensionar, posicionar nem precificar capacidade sem os seus números, e sem eles você também não consegue avaliar a resposta. Este post lista o que definir antes de pedir, com um exemplo de extração de dados de notas fiscais, e termina com um script que confere o endpoint que você receber.

Vale para qualquer provedor. Onde descreve a oferta da BroadNet, ele se limita ao que a BroadNet diz publicamente, conferido em 15 de novembro de 2026. Qualquer coisa além disso é pergunta para a BroadNet.

## Quando um endpoint privado faz sentido?

Geralmente por um destes quatro motivos:

-   **Tráfego acima dos limites do autoatendimento.** A referência da API da BroadNet publica 30 requisições por minuto e 4 requisições simultâneas para uma chave de pagamento por uso. Uma carga constante acima disso é questão de capacidade, não de novas tentativas. ([Como lidar com 429](https://broadrouter.com/pt/blog/handle-llm-api-429-rate-limits/) cobre picos curtos.)
-   **Um modelo que não está na lista pública.** O catálogo da BroadNet marca alguns modelos como “available on request” (disponíveis sob consulta), entre eles Qwen3-VL 30B-A3B, Qwen3-VL 8B e um fine-tune da BroadNet do Cohere Transcribe Arabic. [Como ler um catálogo de modelos](https://broadrouter.com/pt/blog/understand-model-status/) explica a diferença.
-   **Um local de processamento que você precisa controlar.** Regras de residência de dados, como as do [checklist da PDPL da Arábia Saudita e dos Emirados](https://broadrouter.com/pt/blog/saudi-uae-pdpl-llm-api-checklist/), podem exigir uma região combinada por escrito.
-   **Latência previsível.** A capacidade compartilhada varia com a carga dos outros usuários. A capacidade reservada elimina essa variável, mas não a distância de rede nem o tamanho dos seus prompts.

Se nenhum desses motivos se aplica, uma chave de autoatendimento é mais simples. E, se o seu volume é muito alto e constante, compare com rodar por conta própria: [self-hosting vs. custo de API](https://broadrouter.com/pt/blog/self-hosting-llm-vs-api-cost/) traz o método.

## O que definir sobre a carga de trabalho?

Escreva um briefing de uma página. Estes são os números de que um provedor precisa:

| Item | O que anotar | Exemplo |
| --- | --- | --- |
| Tarefa | O que o modelo faz, em uma frase | Lê fotos de notas fiscais e devolve campos em JSON |
| Volume | Requisições por dia e a fatia na hora de pico | 40.000 por dia, 15% na hora de pico |
| Tokens | Média e percentil 95 de tokens de entrada e saída | 1.800 de entrada (imagem de uma página + prompt), 350 de saída |
| Contexto | A maior requisição individual, prompt mais resposta | 4.000 tokens |
| Latência | Tempo aceitável até o primeiro token e até a resposta completa | Resposta completa em até 10 segundos |
| Streaming | Necessário ou não | Não necessário (estilo lote) |
| Entradas | Texto, imagens, áudio; formatos e tamanhos | JPEG e PNG, uma página cada |
| Idiomas | Quais, e a fatia de cada um | Árabe e inglês, 60/40 |
| Crescimento | Volume esperado em 6 e 12 meses | O dobro em 12 meses |

Meça as contagens de tokens em amostras reais, não em chutes. O árabe costuma precisar de mais tokens que o inglês para o mesmo texto; o [contador de tokens em árabe](https://broadrouter.com/tools/arabic-token-counter/) e o [custo real por idioma](https://broadrouter.com/data/real-cost-by-language/) mostram quanto em tokenizers diferentes. Para imagens, a [calculadora de tokens de imagem](https://broadrouter.com/tools/image-token-calculator/) dá uma primeira estimativa.

## Como transformar volume em tokens por segundo e concorrência?

As requisições por segundo no pico são o volume da hora de pico dividido por 3.600. A concorrência, o número de requisições em andamento ao mesmo tempo, sai da [lei de Little](https://en.wikipedia.org/wiki/Little%27s_law): o número médio de itens em um sistema é igual à taxa de chegada vezes o tempo médio que cada um passa nele. Para uma API, isso é requisições por segundo × segundos por requisição.

```python
import math

def size(requests_per_day: int, peak_share_of_day_in_busiest_hour: float,
         in_tokens: int, out_tokens: int, out_tok_per_s_per_stream: float) -> dict:
    """Rough peak numbers to put in a capacity enquiry. Measure your own inputs; these are not provider specs."""
    peak_rps = requests_per_day * peak_share_of_day_in_busiest_hour / 3600
    seconds_per_request = out_tokens / out_tok_per_s_per_stream        # ignores queueing and prompt time
    concurrency = peak_rps * seconds_per_request                      # Little's law: L = λ × W
    return {
        "peak_requests_per_second": round(peak_rps, 2),
        "seconds_per_request": round(seconds_per_request, 1),
        "concurrent_requests_at_peak": math.ceil(concurrency),
        "peak_input_tokens_per_second": round(peak_rps * in_tokens),
        "peak_output_tokens_per_second": round(peak_rps * out_tokens),
        "monthly_tokens_millions": round(requests_per_day * 30 * (in_tokens + out_tokens) / 1e6, 1),
    }

# 40,000 invoice extractions a day, 15% of them in the busiest hour,
# 1,800 tokens in, 350 out, 60 tokens/s per stream measured on a trial.
print(size(40_000, 0.15, 1_800, 350, 60))
```

Ele imprimiu 1,67 requisição por segundo no pico, cerca de 5,8 segundos por requisição, 10 requisições simultâneas, 3.000 tokens de entrada e 583 de saída por segundo, e 2.580 milhões de tokens por mês. Os 60 tokens por segundo são uma suposição do exemplo; meça os seus no modelo que você vai usar, porque a velocidade varia com o modelo, o tamanho do prompt e a carga. O post sobre [latência, TTFT e throughput](https://broadrouter.com/pt/blog/llm-latency-ttft-throughput/) explica o que cronometrar.

Dois cuidados. A fórmula ignora o tempo de processamento do prompt, então prompts longos ou imagens grandes deixam as requisições reais mais lentas e aumentam a concorrência. E médias escondem picos: passe ao provedor o tamanho de requisição no percentil 95 e um perfil curto de rajadas, não só a média. O pico deste exemplo (cerca de 100 requisições por minuto e 10 em andamento) fica bem acima dos limites publicados de autoatendimento para uma chave de pagamento por uso, e é exatamente aí que vale a pena conversar sobre capacidade.

## E região, residência e limites?

Combine tudo explicitamente, por escrito, antes que qualquer dado regulado circule. Os Termos da BroadNet (§7.3a) dizem: “Contact us to agree processing locations for your deployment before sending data with residency requirements” (tradução: fale conosco para combinar os locais de processamento da sua implantação antes de enviar dados com requisitos de residência), e que o processamento hospedado por parceiros e o de backup envolvem outros operadores, com uma lista atualizada de suboperadores disponível aos clientes mediante solicitação. A declaração de privacidade diz que os modelos próprios e os modelos open-weight hospedados pela BroadNet rodam em hardware próprio ou alugado pela BroadNet nos Estados Unidos, com capacidade de parceiros como backup, e a página de visão geral diz que processamento regional no MENA ou na Europa está disponível sob consulta.

Então as perguntas para qualquer provedor são:

1.  Qual região processa as requisições e qual região guarda a capacidade de backup?
2.  Quais suboperadores podem tocar no tráfego, inclusive em failover ou excesso de demanda?
3.  Quais são os limites de taxa, concorrência e tokens do endpoint, e o que acontece acima deles?
4.  Que termos de disponibilidade e suporte se aplicam, e onde estão escritos? Os Termos da BroadNet (§7.4) dizem que o autoatendimento não tem compromisso de disponibilidade e que endpoints privados e capacidade reservada seguem o seu acordo escrito separado. Para ver o que os SLAs escritos de outros provedores cobrem, leia [SLAs de APIs de LLM comparados](https://broadrouter.com/pt/blog/llm-api-sla-uptime-compared/).
5.  O que é retido? Para a API de inferência da BroadNet, a posição publicada é: o conteúdo das requisições de inferência não é retido; os metadados necessários de conta, cobrança e segurança são retidos conforme descrito na [declaração de privacidade](https://www.broadnet.ai/inference-privacy). Confirme que o mesmo vale para o seu endpoint.

## Qual modelo, e com qual licença?

Indique o modelo e a versão exatos e confira se a licença permite o seu uso e o serving via API. As páginas de modelos da BroadNet listam Apache-2.0 para Gemma 4 26B, Qwen3-VL 30B-A3B e os pesos base do Cohere Transcribe, com o fine-tune da BroadNet do Cohere Transcribe Arabic “under contract” (sob contrato). Os Termos dizem que os modelos são regidos por suas licenças e que a licença do DeepSeek V4.1 Flash continua valendo quando ele é hospedado por parceiros.

Combine também a janela de contexto. Os limites de contexto dependem do modelo e da implantação, não só do máximo do modelo base: a BroadNet lista 32K tokens para o Gemma 4 VL 26B na API pública e 16K para o Qwen3-VL 30B-A3B, que é sob consulta. Use a [calculadora de janela de contexto](https://broadrouter.com/tools/context-window-calculator/) com a sua maior requisição, não com a média.

## Como definir um orçamento?

A BroadNet não publica preço de endpoint privado; a página de visão geral diz “Reserved GPU, priced to your traffic. Ask for a quote.” (tradução: GPU reservada, com preço conforme o seu tráfego. Peça um orçamento.). Então defina antes o seu próprio teto. Precifique a mesma carga no autoatendimento com a [calculadora de custo de API de LLM](https://broadrouter.com/tools/llm-api-cost-calculator/), usando a contagem mensal de tokens do script de dimensionamento, e decida quanto valem para você, além disso, capacidade previsível, uma região ou um modelo que não é público. Um orçamento abaixo do valor de autoatendimento é bônus; um muito acima precisa de uma justificativa na sua lista de requisitos.

## Como enviar a consulta?

A referência da API da BroadNet diz: “Private endpoints, our Arabic fine-tunes and other models on request are reached with a private ID issued with the endpoint” (tradução: endpoints privados, nossos fine-tunes para árabe e outros modelos sob consulta são acessados com um ID privado emitido junto com o endpoint). A página de visão geral pede “your model, languages and traffic requirements” (tradução: seu modelo, idiomas e requisitos de tráfego). Envie seu briefing de uma página pela [página de contato](https://broadrouter.com/pt/contact/#private), sem chaves de API nem dados de clientes. Inclua a saída do dimensionamento, a região, o modelo e a licença, a meta de latência, o teto de orçamento e o seu cronograma.

## Como validar o endpoint recebido?

Antes do tráfego de produção, teste o endpoint contra o que foi combinado. Este script usa só a biblioteca padrão do Python. Ele confere se o ID privado do modelo funciona, se o streaming termina com o marcador `data: [DONE]` que a documentação da BroadNet descreve, se a concorrência combinada roda sem 429 e se um ID de modelo errado é rejeitado.

```python
import json, os, sys, time, urllib.error, urllib.request
from concurrent.futures import ThreadPoolExecutor

BASE = os.environ["ENDPOINT_BASE_URL"].rstrip("/")    # from your agreement, e.g. https://.../v1
KEY = os.environ["ENDPOINT_API_KEY"]
MODEL = os.environ["ENDPOINT_MODEL_ID"]                # the private ID issued with the endpoint
AGREED_CONCURRENCY = int(os.environ.get("AGREED_CONCURRENCY", "4"))

def post(payload: dict, stream=False):
    req = urllib.request.Request(f"{BASE}/chat/completions", data=json.dumps(payload).encode(),
        headers={"Authorization": f"Bearer {KEY}", "Content-Type": "application/json"})
    t0 = time.monotonic()
    try:
        with urllib.request.urlopen(req, timeout=120) as r:
            body = r.read().decode()
            return r.status, r.headers.get("X-Request-ID"), body, time.monotonic() - t0
    except urllib.error.HTTPError as e:
        return e.code, e.headers.get("X-Request-ID"), e.read().decode(), time.monotonic() - t0

def main() -> int:
    msg = [{"role": "user", "content": "Reply with the word OK."}]
    results = {}
    code, rid, body, secs = post({"model": MODEL, "messages": msg, "max_tokens": 1000})
    ok = code == 200 and "usage" in json.loads(body)
    results["model_id_accepted"] = (ok, f"HTTP {code}, request ID {rid}, {secs:.2f}s")
    code, _, body, _ = post({"model": MODEL, "messages": msg, "stream": True,
                             "stream_options": {"include_usage": True}})
    results["stream_ends_with_DONE"] = (code == 200 and body.rstrip().endswith("data: [DONE]"), f"HTTP {code}")
    with ThreadPoolExecutor(AGREED_CONCURRENCY) as pool:
        codes = list(pool.map(lambda _: post({"model": MODEL, "messages": msg, "max_tokens": 1000})[0],
                              range(AGREED_CONCURRENCY)))
    results["agreed_concurrency_no_429"] = (all(c == 200 for c in codes), f"codes {sorted(codes)}")
    code, _, _, _ = post({"model": MODEL + "-typo", "messages": msg})
    results["unknown_model_rejected"] = (code in (400, 403, 404), f"HTTP {code}")
    for name, (passed, note) in results.items():
        print(f"{'PASS' if passed else 'FAIL'}  {name}: {note}")
    return 0 if all(p for p, _ in results.values()) else 1

if __name__ == "__main__":
    sys.exit(main())
```

Rodamos o script contra um servidor mock local (sem endpoint real) que permite 8 requisições simultâneas. Com `AGREED_CONCURRENCY=8`, as quatro verificações passaram. Com 12, a verificação de concorrência falhou com oito 200 e quatro 429, que é o resultado que você quer ver antes do lançamento, não depois. `max_tokens=1000` deixa espaço para modelos de raciocínio, que gastam parte do orçamento antes de responder.

Depois do smoke test, rode um teste de carga curto no seu pico medido, com prompts de tamanho real, e registre o tempo até o primeiro token e a latência da resposta completa do endpoint. Guarde os request IDs; a documentação da BroadNet pede o `X-Request-ID`, o timestamp, a rota e o status nos pedidos de suporte.

## Onde a BroadNet Inference se encaixa

O BroadRouter é o site da própria BroadNet. A BroadNet Inference vende acesso de autoatendimento a modelos públicos por token, por minuto de áudio, por plano de sessão e por chave por hora; os preços estão na [página de preços](https://broadrouter.com/pt/pricing/). Endpoints privados, processamento regional, fine-tunes e modelos listados “on request” (sob consulta) não são autoatendimento: são consultas que a BroadNet orça e combina por escrito. Este post não pode dizer o que a BroadNet vai oferecer para a sua carga de trabalho. Um briefing claro é como você descobre.

Ferramentas gratuitas sobre o tema (em 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.

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

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

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

[Concorrência (concurrency)](https://broadrouter.com/pt/glossary/concurrency/)

Concorrência é o número de requisições que um cliente tem em andamento ao mesmo tempo. APIs de LLM muitas vezes a limitam por chave ou por plano, separadamente das requisições por minuto, porque cada requisição aberta ocupa capacidade de GPU até a resposta terminar.

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

Pagamento por uso é um modelo de preço em que você paga só pelo que usa, medido por unidade, como tokens, requisições ou minutos de áudio, sem assinatura nem compromisso mínimo. A maioria das APIs de LLM cobra assim, a partir de um saldo pré-pago ou de uma fatura periódica.

[Streaming](https://broadrouter.com/pt/glossary/streaming/)

Streaming é uma forma de devolver a resposta de um modelo de linguagem em pequenos pedaços enquanto ela ainda está sendo gerada, em vez de uma resposta única no final. APIs compatíveis com a OpenAI fazem streaming via server-sent events quando a requisição define stream como true.

[Throughput (vazão)](https://broadrouter.com/pt/glossary/throughput/)

Throughput, ou vazão, no serving de LLMs, é a quantidade total de trabalho que um sistema conclui por unidade de tempo em todas as requisições simultâneas, geralmente medida em tokens de saída ou requisições por segundo. É diferente da velocidade por stream, que é a rapidez com que uma única requisição recebe seus tokens.

[Tool calling (chamada de ferramentas)](https://broadrouter.com/pt/glossary/tool-calling/)

Tool calling, também chamado de function calling ou chamada de ferramentas, é um recurso de APIs de LLM em que o modelo devolve um pedido estruturado para executar uma função definida pelo desenvolvedor, com argumentos JSON. A aplicação executa a função e devolve o resultado; o modelo nunca executa código sozinho.

[Rate limit (limite de taxa)](https://broadrouter.com/pt/glossary/rate-limit/)

Um rate limit é um teto que uma API impõe a quanto um cliente pode usá-la em um intervalo de tempo, como requisições por minuto ou tokens por minuto. As requisições acima do limite são recusadas, normalmente com HTTP 429 Too Many Requests, até que o uso volte a ficar abaixo dele.

[Janela de contexto (context window)](https://broadrouter.com/pt/glossary/context-window/)

A janela de contexto é o número máximo de tokens com que um modelo de linguagem consegue trabalhar em uma única requisição. Ela abrange o prompt, o histórico da conversa, as definições de ferramentas, as imagens e a saída gerada, incluindo os tokens de raciocínio. O que não couber precisa ser cortado, resumido ou dividido em várias requisições.

## Perguntas frequentes

### O que é um endpoint privado de LLM?

Um endpoint de API apoiado em capacidade reservada para um único cliente, em vez de compartilhada com todos os usuários de autoatendimento. A BroadNet descreve a versão dela como uma GPU ou nó reservado com o modelo que você escolher, chave e limites próprios e a região de que você precisa, acessado por um ID de modelo privado.

### Como estimar a concorrência de que preciso?

Use a lei de Little: requisições simultâneas = requisições por segundo no pico × segundos por requisição. 1,67 requisição por segundo com cerca de 5,8 segundos cada dá cerca de 10 requisições em andamento. Meça os segundos por requisição no modelo real, com os seus prompts reais.

### Posso contratar um endpoint privado da BroadNet por autoatendimento?

Não. A BroadNet trata endpoints privados, processamento regional e modelos fora da lista como consultas: você descreve a carga de trabalho e a BroadNet faz um orçamento. Os Termos dela dizem que endpoints privados e capacidade reservada seguem um acordo escrito separado.

### Um endpoint privado vem com SLA?

Só se o seu acordo escrito disser isso. Os Termos da BroadNet afirmam que o autoatendimento não tem compromisso de disponibilidade e que níveis de serviço só existem em um acordo escrito separado. Peça os termos exatos antes de contar com eles.

### Onde meus dados serão processados?

Combine isso antes de enviar dados. Os Termos da BroadNet pedem que clientes com requisitos de residência combinem antes os locais de processamento, e dizem que o processamento hospedado por parceiros e o de backup envolvem outros operadores, com uma lista de suboperadores disponível aos clientes mediante solicitação.

## Continue lendo

-   [Hospedar um LLM próprio ou usar API: custo real e ponto de equilíbrio](https://broadrouter.com/pt/blog/self-hosting-llm-vs-api-cost/)
-   [Latência de LLM: TTFT, tokens por segundo e tempo de ponta a ponta](https://broadrouter.com/pt/blog/llm-latency-ttft-throughput/)
-   [PDPL saudita e dos EAU e APIs de LLM: checklist de transferência](https://broadrouter.com/pt/blog/saudi-uae-pdpl-llm-api-checklist/)
-   [Como escolher um provedor de API de LLM: checklist de 20 pontos](https://broadrouter.com/pt/blog/choose-llm-api-provider-checklist/)
-   [Como estimar o custo de API de LLM antes de lançar uma funcionalidade](https://broadrouter.com/pt/blog/estimate-llm-api-cost-before-launch/)
-   [Erro 429 em API de LLM: backoff, jitter e limitadores](https://broadrouter.com/pt/blog/handle-llm-api-429-rate-limits/)
-   [Live, sob consulta, pesquisa: como ler um catálogo de modelos](https://broadrouter.com/pt/blog/understand-model-status/)
-   [Hardware de GPU e serving da BroadNet, segundo a própria BroadNet](https://broadrouter.com/pt/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache de respostas de LLM para cortar custo: um cache exato em Python](https://broadrouter.com/pt/blog/cache-llm-responses-cut-cost/)
-   [Guia: Códigos de erro da BroadNet Inference e quando tentar de novo](https://broadrouter.com/pt/guides/errors-and-retries/)
-   [Guia: Restrinja chaves de API aos seus servidores com lista de IPs](https://broadrouter.com/pt/guides/api-keys-ip-allow-lists/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

[Começar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-private-endpoint-planning&utm_content=page-cta) ·

**Fontes**

-   [Visão geral da BroadNet Inference: endpoint privado “Reserved GPU, priced to your traffic”, processamento regional sob consulta (consultada em 2026-11-15) (em inglês)](https://www.broadnet.ai/inference)
-   [Catálogo de modelos da BroadNet: disponíveis sob consulta, endpoints privados multi-GPU dimensionados por cliente (consultado em 2026-11-15) (em inglês)](https://www.broadnet.ai/inference/models)
-   [Página do modelo BroadNet, Qwen3-VL 30B-A3B Instruct: sob consulta, ID privado emitido por cliente, contexto de 16K (consultada em 2026-11-15) (em inglês)](https://www.broadnet.ai/inference/models/qwen3-vl-30b-a3b)
-   [Página do modelo BroadNet, Gemma 4 VL 26B: endpoint privado com chave, limites e região próprios (consultada em 2026-11-15) (em inglês)](https://www.broadnet.ai/inference/models/gemma-4-vl-26b)
-   [Termos de Serviço da BroadNet, §7.3a locais de hospedagem e processamento e §7.4 disponibilidade, última atualização em 23 de setembro de 2026 (consultados em 2026-11-15) (em inglês)](https://www.broadnet.ai/terms)
-   [Referência da API da BroadNet Inference: IDs privados, limites do pagamento por uso, streaming, erros (consultada em 2026-11-15) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-private-endpoint-planning&utm_content=sources)
-   [Declaração de privacidade e retenção de dados da BroadNet Inference: onde o processamento acontece (consultada em 2026-11-15) (em inglês)](https://www.broadnet.ai/inference-privacy)
-   [Lei de Little, L = λW (Wikipédia, consultada em 2026-11-15)](https://en.wikipedia.org/wiki/Little%27s_law)
