---
title: "Endpoint LLM privato: che cosa definire prima | BroadRouter"
description: "Che cosa definire prima di chiedere un endpoint LLM privato: carico di lavoro, token al secondo, concorrenza, contesto, regione, licenza e budget, e come testarlo."
url: https://broadrouter.com/it/blog/private-endpoint-planning/
lang: it
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Tradotto dall’inglese con l’aiuto dell’IA. [Leggi l’originale in inglese](https://broadrouter.com/blog/private-endpoint-planning/) (aggiornato il 2026-11-15).

# Un endpoint privato parte da un carico di lavoro chiaro

A cura del team di BroadNet Inference · 7 min di lettura · Pubblicato 2026-11-15

Prima di chiedere un endpoint privato, metti per iscritto il carico di lavoro: richieste al giorno e nel picco, token in ingresso e in uscita, la concorrenza che ne deriva, il contesto necessario, la regione di elaborazione, il modello e la sua licenza, e un budget. Concorda per iscritto regione e limiti, poi fai uno smoke test sull’endpoint ricevuto prima di usare dati reali.

## Punti chiave

-   Una richiesta di capacità vale quanto i suoi numeri: richieste al secondo nel picco, token in ingresso e in uscita e la latenza che puoi accettare.
-   La concorrenza segue dalla legge di Little: richieste in corso = frequenza di arrivo × tempo per richiesta. Misura prima il tempo per richiesta con una prova.
-   BroadNet descrive pubblicamente gli endpoint privati come capacità GPU riservata con prezzo in base al tuo traffico, con chiave, limiti e regione tuoi, raggiungibile con un ID di modello privato. Tutto il resto si concorda con BroadNet.
-   I Termini di BroadNet dicono che il self-service non ha alcun impegno di disponibilità e che endpoint privati e capacità riservata seguono un accordo scritto separato.
-   Testa l’endpoint ricevuto prima della produzione: ID del modello, streaming, la concorrenza concordata e l’errore per un ID di modello sbagliato.

**In questa pagina**

1.  Quando ha senso un endpoint privato?
2.  Che cosa definire del carico di lavoro?
3.  Come si trasforma il volume in token al secondo e concorrenza?
4.  E regione, residenza e limiti?
5.  Quale modello, e con quale licenza?
6.  Come si fissa un budget?
7.  Come si invia la richiesta?
8.  Come si convalida l’endpoint ricevuto?
9.  Dove si inserisce BroadNet Inference

“Ci serve un endpoint dedicato” è l’inizio di una conversazione, non una specifica. Il provider non può dimensionare, collocare o prezzare la capacità senza i tuoi numeri, e senza di essi nemmeno tu puoi giudicare la sua risposta. Questo articolo elenca che cosa definire prima di chiedere, con un esempio concreto di estrazione dati dalle fatture, e si chiude con uno script che verifica l’endpoint che ricevi.

Vale per qualsiasi provider. Dove descrive l’offerta di BroadNet, si limita a ciò che BroadNet dice pubblicamente, verificato il 15 novembre 2026. Tutto il resto è una domanda da fare a BroadNet.

## Quando ha senso un endpoint privato?

Di solito per uno di quattro motivi:

-   **Traffico oltre i limiti self-service.** Il riferimento API di BroadNet pubblica 30 richieste al minuto e 4 richieste in corso per una chiave a consumo. Un carico costante oltre queste soglie è una questione di capacità, non di retry. ([Gestire gli errori 429](https://broadrouter.com/it/blog/handle-llm-api-429-rate-limits/) copre i picchi brevi.)
-   **Un modello che non è nell’elenco pubblico.** Il catalogo di BroadNet segna alcuni modelli come “available on request” (disponibili su richiesta), tra cui Qwen3-VL 30B-A3B, Qwen3-VL 8B e un fine-tune di BroadNet di Cohere Transcribe Arabic. [Leggere un catalogo di modelli](https://broadrouter.com/it/blog/understand-model-status/) spiega la differenza.
-   **Un luogo di elaborazione che devi controllare.** Le norme sulla residenza dei dati, come quelle della [checklist PDPL per Arabia Saudita ed Emirati](https://broadrouter.com/it/blog/saudi-uae-pdpl-llm-api-checklist/), possono richiedere una regione concordata per iscritto.
-   **Latenza prevedibile.** La capacità condivisa varia con il carico degli altri utenti. La capacità riservata elimina questa variabile, anche se non la distanza di rete né la dimensione dei tuoi prompt.

Se nessuno di questi motivi vale per te, una chiave self-service è più semplice. E se il tuo volume è molto alto e costante, fai un confronto con la gestione in proprio: [self-hosting o API, i costi](https://broadrouter.com/it/blog/self-hosting-llm-vs-api-cost/) contiene il metodo.

## Che cosa definire del carico di lavoro?

Scrivi un brief di una pagina. Questi sono i numeri che servono a un provider:

| Voce | Che cosa scrivere | Esempio |
| --- | --- | --- |
| Compito | Che cosa fa il modello, in una frase | Legge foto di fatture, restituisce campi JSON |
| Volume | Richieste al giorno e quota nell’ora di punta | 40.000 al giorno, il 15% nell’ora di punta |
| Token | Token medi e al 95° percentile in ingresso e in uscita | 1.800 in ingresso (immagine di una pagina + prompt), 350 in uscita |
| Contesto | La singola richiesta più grande, prompt più risposta | 4.000 token |
| Latenza | Tempo accettabile al primo token e alla risposta completa | Risposta completa entro 10 secondi |
| Streaming | Necessario o no | Non necessario (in stile batch) |
| Input | Testo, immagini, audio; formati e dimensioni | JPEG e PNG, una pagina ciascuno |
| Lingue | Quali, e la quota di ciascuna | Arabo e inglese, 60/40 |
| Crescita | Volume previsto a 6 e 12 mesi | Il doppio in 12 mesi |

Misura i conteggi dei token su campioni reali, non a stima. L’arabo richiede spesso più token dell’inglese per lo stesso testo; il [contatore di token per l’arabo](https://broadrouter.com/tools/arabic-token-counter/) e [il costo reale per lingua](https://broadrouter.com/data/real-cost-by-language/) mostrano di quanto con tokenizer diversi. Per le immagini, il [calcolatore di token per immagini](https://broadrouter.com/tools/image-token-calculator/) dà una prima stima.

## Come si trasforma il volume in token al secondo e concorrenza?

Le richieste al secondo nel picco sono il volume dell’ora di punta diviso per 3.600. La concorrenza, cioè il numero di richieste in corso nello stesso momento, segue dalla [legge di Little](https://en.wikipedia.org/wiki/Little%27s_law): il numero medio di elementi in un sistema è uguale alla frequenza di arrivo per il tempo medio che ciascuno vi trascorre. Per un’API: richieste al secondo × secondi per richiesta.

```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))
```

Ha stampato 1,67 richieste al secondo nel picco, circa 5,8 secondi per richiesta, 10 richieste concorrenti, 3.000 token di input e 583 di output al secondo, e 2.580 milioni di token al mese. I 60 token al secondo sono un’ipotesi per l’esempio; misura i tuoi sul modello che userai, perché la velocità varia con il modello, la lunghezza del prompt e il carico. L’articolo su [latenza, TTFT e throughput](https://broadrouter.com/it/blog/llm-latency-ttft-throughput/) spiega che cosa cronometrare.

Due avvertenze. La formula ignora il tempo di elaborazione del prompt, quindi prompt lunghi o immagini grandi rendono le richieste reali più lente e fanno salire la concorrenza. E le medie nascondono i picchi: dai al provider la dimensione delle richieste al 95° percentile e un breve profilo dei burst, non solo la media. Il picco di questo esempio (circa 100 richieste al minuto e 10 in corso) è ben oltre i limiti self-service pubblicati per una singola chiave a consumo, ed è proprio il momento in cui vale la pena parlare di capacità.

## E regione, residenza e limiti?

Concordali esplicitamente, per iscritto, prima di spostare qualsiasi dato regolamentato. I Termini di BroadNet (§7.3a) dicono: «Contact us to agree processing locations for your deployment before sending data with residency requirements» (traduzione: contattaci per concordare i luoghi di elaborazione del tuo deployment prima di inviare dati con requisiti di residenza), e che l’elaborazione ospitata da partner e quella di backup coinvolgono altri responsabili del trattamento, con un elenco aggiornato dei sub-responsabili disponibile ai clienti su richiesta. La sua informativa privacy dice che i modelli open-weight propri e ospitati da BroadNet girano su hardware di proprietà o in leasing di BroadNet negli Stati Uniti, con capacità di partner come backup, e la pagina di panoramica dice che l’elaborazione regionale in MENA o in Europa è disponibile su richiesta.

Le domande da fare a qualsiasi provider sono quindi:

1.  Quale regione elabora le richieste, e quale regione ospita la capacità di backup?
2.  Quali sub-responsabili possono toccare il traffico, anche in caso di failover o di sovraccarico?
3.  Quali sono i limiti di frequenza, concorrenza e token dell’endpoint, e che cosa succede oltre?
4.  Quali termini di disponibilità e di supporto si applicano, e dove sono scritti? I Termini di BroadNet (§7.4) dicono che il self-service non ha impegni di disponibilità e che endpoint privati e capacità riservata seguono il tuo accordo scritto separato. Per vedere che cosa coprono gli SLA scritti di altri provider, leggi [gli SLA delle API LLM a confronto](https://broadrouter.com/it/blog/llm-api-sla-uptime-compared/).
5.  Che cosa viene conservato? Per l’API di inferenza di BroadNet, la posizione pubblicata è: il contenuto delle richieste di inferenza non viene conservato; i metadati necessari di account, fatturazione e sicurezza vengono conservati come descritto nella sua [informativa privacy](https://www.broadnet.ai/inference-privacy). Verifica che valga lo stesso per il tuo endpoint.

## Quale modello, e con quale licenza?

Indica il modello e la versione esatti, e controlla che la licenza consenta il tuo uso e il serving via API. Le pagine dei modelli di BroadNet indicano Apache-2.0 per Gemma 4 26B, Qwen3-VL 30B-A3B e i pesi di base di Cohere Transcribe, mentre il fine-tune di BroadNet di Cohere Transcribe Arabic è «under contract» (sotto contratto). I suoi Termini dicono che i modelli sono regolati dalle rispettive licenze, e che la licenza di DeepSeek V4.1 Flash si applica anche quando è ospitato da partner.

Concorda anche la finestra di contesto. I limiti di contesto dipendono dal modello e dal deployment, non solo dal massimo del modello di base: BroadNet indica 32K token per Gemma 4 VL 26B sulla sua API pubblica e 16K per Qwen3-VL 30B-A3B, che è su richiesta. Usa il [calcolatore della finestra di contesto](https://broadrouter.com/tools/context-window-calculator/) sulla tua richiesta più grande, non su quella media.

## Come si fissa un budget?

BroadNet non pubblica un prezzo per gli endpoint privati; la sua pagina di panoramica dice «Reserved GPU, priced to your traffic. Ask for a quote.» (traduzione: GPU riservata, con prezzo in base al tuo traffico. Chiedi un preventivo.). Fissa quindi prima un tuo tetto. Prezza lo stesso carico in self-service con il [calcolatore dei costi delle API LLM](https://broadrouter.com/tools/llm-api-cost-calculator/), usando il conteggio mensile dei token dello script di dimensionamento, e decidi quanto valgono per te, in aggiunta, capacità prevedibile, una regione o un modello non pubblico. Un preventivo sotto la cifra self-service è un bonus; uno molto sopra richiede una giustificazione dal tuo elenco di requisiti.

## Come si invia la richiesta?

Il riferimento API di BroadNet dice: «Private endpoints, our Arabic fine-tunes and other models on request are reached with a private ID issued with the endpoint» (traduzione: gli endpoint privati, i nostri fine-tune per l’arabo e gli altri modelli su richiesta si raggiungono con un ID privato rilasciato insieme all’endpoint). La sua pagina di panoramica chiede «your model, languages and traffic requirements» (traduzione: il tuo modello, le lingue e i requisiti di traffico). Invia il tuo brief di una pagina dalla [pagina dei contatti](https://broadrouter.com/it/contact/#private), senza chiavi API né dati dei clienti. Includi l’output del dimensionamento, la regione, il modello e la licenza, l’obiettivo di latenza, il tetto di budget e le tue tempistiche.

## Come si convalida l’endpoint ricevuto?

Prima del traffico di produzione, testa l’endpoint rispetto a quanto concordato. Questo script usa solo la libreria standard di Python. Verifica che l’ID privato del modello funzioni, che lo streaming termini con il marcatore `data: [DONE]` descritto nella documentazione di BroadNet, che la concorrenza concordata giri senza 429 e che un ID di modello sbagliato venga rifiutato.

```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())
```

L’abbiamo eseguito contro un server mock locale (nessun endpoint reale) che consente 8 richieste in corso. Con `AGREED_CONCURRENCY=8` tutti e quattro i controlli sono passati. Con 12, il controllo di concorrenza è fallito con otto 200 e quattro 429: è il risultato che vuoi vedere prima del lancio, non dopo. `max_tokens=1000` lascia spazio ai modelli di ragionamento, che spendono parte del budget prima di rispondere.

Dopo lo smoke test, esegui un breve test di carico al tuo picco misurato con prompt di dimensioni reali, e registra il tempo al primo token e la latenza della risposta completa dell’endpoint. Conserva i request ID; la documentazione di BroadNet chiede `X-Request-ID`, timestamp, route e stato nelle richieste di supporto.

## Dove si inserisce BroadNet Inference

BroadRouter è il sito di BroadNet. BroadNet Inference vende accesso self-service ai modelli pubblici per token, per minuto di audio, con piani a sessione e con chiavi orarie; i prezzi sono nella [pagina prezzi](https://broadrouter.com/it/pricing/). Endpoint privati, elaborazione regionale, fine-tune e modelli indicati “on request” (su richiesta) non sono self-service: sono richieste per cui BroadNet fa un preventivo e che concorda per iscritto. Questo articolo non può dirti che cosa BroadNet offrirà per il tuo carico di lavoro. Un brief chiaro è il modo per scoprirlo.

Strumenti gratuiti sul tema (in inglese)

-   [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.

[Strumenti gratuiti (in inglese)](https://broadrouter.com/tools/)

## Termini in questo articolo

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

Un token è l’unità di testo che un modello linguistico legge e scrive: una parola, una parte di parola, un segno di punteggiatura o una sequenza di byte prodotta dal tokenizer del modello. Le API LLM contano, limitano e di solito fatturano l’uso in token.

[Concorrenza (concurrency)](https://broadrouter.com/it/glossary/concurrency/)

La concorrenza è il numero di richieste che un client ha in corso nello stesso momento. Le API LLM spesso la limitano per chiave o per piano, separatamente dalle richieste al minuto, perché ogni richiesta aperta occupa capacità GPU finché la sua risposta non è terminata.

[Throughput](https://broadrouter.com/it/glossary/throughput/)

Il throughput, nel serving di LLM, è la quantità totale di lavoro che un sistema completa per unità di tempo su tutte le richieste concorrenti, di solito misurata in token di output al secondo o richieste al secondo. È diverso dalla velocità per stream, cioè quanto rapidamente una singola richiesta riceve i suoi token.

[Pagamento a consumo (pay-as-you-go)](https://broadrouter.com/it/glossary/pay-as-you-go/)

Il pagamento a consumo è un modello di prezzo in cui paghi solo ciò che usi, misurato per unità come token, richieste o minuti di audio, senza abbonamento né impegno minimo. La maggior parte delle API LLM fattura così, da un saldo prepagato o con una fattura periodica.

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

Lo streaming è un modo di restituire la risposta di un modello linguistico in piccoli pezzi mentre viene ancora generata, invece che in un’unica risposta alla fine. Le API compatibili con OpenAI trasmettono in streaming tramite server-sent event quando la richiesta imposta stream a true.

[Tool calling (chiamata di strumenti)](https://broadrouter.com/it/glossary/tool-calling/)

Il tool calling, detto anche function calling, è una funzionalità delle API LLM in cui il modello restituisce una richiesta strutturata di eseguire una funzione definita dallo sviluppatore, con argomenti JSON. L’applicazione esegue la funzione e rimanda il risultato; il modello non esegue mai codice da solo.

[Rate limit (limite di frequenza)](https://broadrouter.com/it/glossary/rate-limit/)

Un rate limit è un tetto che un’API pone a quanto un client può usarla in un intervallo di tempo, per esempio richieste al minuto o token al minuto. Le richieste oltre il limite vengono rifiutate, di solito con HTTP 429 Too Many Requests, finché l’uso non torna sotto la soglia.

[Finestra di contesto (context window)](https://broadrouter.com/it/glossary/context-window/)

La finestra di contesto è il numero massimo di token con cui un modello linguistico può lavorare in una singola richiesta. Comprende prompt, cronologia della conversazione, definizioni degli strumenti, immagini e output generato, token di ragionamento inclusi. Ciò che non ci sta va tagliato, riassunto o diviso su più richieste.

## Domande frequenti

### Che cos’è un endpoint LLM privato?

Un endpoint API basato su capacità riservata a un solo cliente, invece che condivisa con tutti gli utenti self-service. BroadNet descrive la sua versione come una GPU o un nodo riservato con il modello che scegli, chiave e limiti tuoi e la regione che ti serve, raggiungibile con un ID di modello privato.

### Come stimo la concorrenza che mi serve?

Usa la legge di Little: richieste concorrenti = richieste al secondo nel picco × secondi per richiesta. 1,67 richieste al secondo da circa 5,8 secondi ciascuna significano circa 10 richieste in corso. Misura i secondi per richiesta sul modello reale con i tuoi prompt reali.

### Posso acquistare un endpoint privato BroadNet in self-service?

No. BroadNet presenta endpoint privati, elaborazione regionale e modelli non in elenco come richieste di informazioni: descrivi il carico di lavoro e BroadNet fa un preventivo. I suoi Termini dicono che endpoint privati e capacità riservata seguono un accordo scritto separato.

### Un endpoint privato include uno SLA?

Solo se il tuo accordo scritto lo prevede. I Termini di BroadNet dicono che il self-service non ha impegni di disponibilità e che i livelli di servizio esistono solo in un accordo scritto separato. Chiedi i termini esatti prima di farci affidamento.

### Dove verranno elaborati i miei dati?

Concordalo prima di inviare dati. I Termini di BroadNet chiedono ai clienti con requisiti di residenza di concordare prima i luoghi di elaborazione, e dicono che l’elaborazione ospitata da partner e quella di backup coinvolgono altri responsabili del trattamento, con un elenco dei sub-responsabili disponibile ai clienti su richiesta.

## Continua a leggere

-   [LLM in self-hosting o via API: costo reale e punto di pareggio](https://broadrouter.com/it/blog/self-hosting-llm-vs-api-cost/)
-   [Latenza degli LLM: TTFT, token al secondo e tempo end-to-end](https://broadrouter.com/it/blog/llm-latency-ttft-throughput/)
-   [PDPL saudita ed emiratina e API LLM: checklist per il trasferimento](https://broadrouter.com/it/blog/saudi-uae-pdpl-llm-api-checklist/)
-   [Come scegliere un provider di API LLM: checklist in 20 punti](https://broadrouter.com/it/blog/choose-llm-api-provider-checklist/)
-   [Come stimare il costo delle API LLM prima di lanciare una funzione](https://broadrouter.com/it/blog/estimate-llm-api-cost-before-launch/)
-   [Errore 429 nelle API LLM: backoff, jitter e limitatori](https://broadrouter.com/it/blog/handle-llm-api-429-rate-limits/)
-   [Live, su richiesta, ricerca: leggere bene un catalogo di modelli](https://broadrouter.com/it/blog/understand-model-status/)
-   [Hardware GPU e serving di BroadNet, come li descrive BroadNet](https://broadrouter.com/it/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache delle risposte delle API LLM: una cache esatta in Python](https://broadrouter.com/it/blog/cache-llm-responses-cut-cost/)
-   [Guida: Codici di errore di BroadNet Inference e quando ritentare](https://broadrouter.com/it/guides/errors-and-retries/)
-   [Guida: Limita le chiavi API ai tuoi server con le allowlist di IP](https://broadrouter.com/it/guides/api-keys-ip-allow-lists/)

Provalo sul tuo carico di lavoro reale. I nuovi account partono con USD 5 di credito per Gemma e trascrizione. DeepSeek, GLM e Qwen3.8 richiedono una ricarica.

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

**Fonti**

-   [Panoramica di BroadNet Inference: endpoint privato «Reserved GPU, priced to your traffic», elaborazione regionale su richiesta (consultata il 2026-11-15) (in inglese)](https://www.broadnet.ai/inference)
-   [Catalogo dei modelli di BroadNet: disponibili su richiesta, endpoint privati multi-GPU dimensionati per cliente (consultato il 2026-11-15) (in inglese)](https://www.broadnet.ai/inference/models)
-   [Pagina del modello BroadNet, Qwen3-VL 30B-A3B Instruct: su richiesta, ID privato rilasciato per cliente, contesto da 16K (consultata il 2026-11-15) (in inglese)](https://www.broadnet.ai/inference/models/qwen3-vl-30b-a3b)
-   [Pagina del modello BroadNet, Gemma 4 VL 26B: endpoint privato con chiave, limiti e regione tuoi (consultata il 2026-11-15) (in inglese)](https://www.broadnet.ai/inference/models/gemma-4-vl-26b)
-   [Termini di servizio di BroadNet, §7.3a luoghi di hosting e di elaborazione e §7.4 disponibilità, ultimo aggiornamento 23 settembre 2026 (consultati il 2026-11-15) (in inglese)](https://www.broadnet.ai/terms)
-   [Riferimento API di BroadNet Inference: ID privati, limiti a consumo, streaming, errori (consultato il 2026-11-15) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-private-endpoint-planning&utm_content=sources)
-   [Informativa di BroadNet Inference su privacy e conservazione dei dati: dove avviene l’elaborazione (consultata il 2026-11-15) (in inglese)](https://www.broadnet.ai/inference-privacy)
-   [Legge di Little, L = λW (Wikipedia, consultata il 2026-11-15)](https://en.wikipedia.org/wiki/Little%27s_law)
