---
title: "LLM usage लॉगिंग: यूज़र और फ़ीचर की लागत, बिना PII | BroadRouter"
description: "हर LLM API कॉल को टोकन, लागत, लेटेंसी और अनुरोध ID के साथ लॉग करें, ख़र्च को यूज़र और फ़ीचर से जोड़ें, और लिखने से पहले PII हटाएँ। Python कोड के साथ।"
url: https://broadrouter.com/hi/blog/llm-api-usage-logging/
lang: hi
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

यह पेज अंग्रेज़ी से AI की मदद से अनुवाद किया गया है। [अंग्रेज़ी मूल पढ़ें](https://broadrouter.com/blog/llm-api-usage-logging/) (2026-11-14 को अपडेट किया गया).

# LLM API usage लॉगिंग: हर यूज़र और फ़ीचर की लागत, PII हटाकर

BroadNet Inference टीम · 4 मिनट में पढ़ें · प्रकाशित 2026-11-14

हर LLM कॉल को एक फ़ंक्शन में लपेटें जो मॉडल, फ़ीचर, हैश किया हुआ यूज़र ID, prompt, cached, reasoning और आउटपुट टोकन, लागत, लेटेंसी, स्टेटस और प्रोवाइडर का अनुरोध ID दर्ज करे। लागत इनवॉइस से नहीं, प्राइस टेबल से निकालें। डिफ़ॉल्ट रूप से मेटाडेटा लॉग करें; अगर प्रॉम्प्ट टेक्स्ट रखना ही है, तो लिखने से पहले उसमें से निजी जानकारी हटाएँ और कम समय की रिटेंशन रखें।

## मुख्य बातें

-   एक रैपर, हर कॉल की एक लॉग लाइन: मॉडल, फ़ीचर, हैश किया हुआ यूज़र, टोकन की संख्या, लागत, लेटेंसी, स्टेटस, अनुरोध ID।
-   हर कॉल की लागत usage ब्लॉक और प्राइस टेबल से निकालें: नए इनपुट, कैश्ड इनपुट और आउटपुट की कीमतें अलग हैं।
-   यूज़र ID को key वाले HMAC से हैश करें, ताकि यूज़र कौन है यह स्टोर किए बिना आप यूज़र के हिसाब से ग्रुप कर सकें।
-   डिफ़ॉल्ट रूप से मेटाडेटा लॉग करें। प्रॉम्प्ट टेक्स्ट PII का मुख्य जोखिम है; उसे लिखने से पहले साफ़ करें, बाद में कभी नहीं।
-   regex और NER, दोनों तरह की रिडैक्शन कुछ चीज़ें छोड़ देती हैं। इन्हें एक परत मानें, गारंटी नहीं।

**इस पेज पर**

1.  हर LLM कॉल के लिए क्या लॉग करें?
2.  हर कॉल की लागत कैसे निकालें?
3.  लॉगिंग रैपर कैसा दिखता है?
4.  लागत को यूज़र्स और फ़ीचर्स से कैसे जोड़ें?
5.  LLM लॉग से PII को बाहर कैसे रखें?
6.  BroadNet Inference कहाँ काम आता है

प्रोवाइडर के डैशबोर्ड बताते हैं कि आपने कितना ख़र्च किया। वे शायद ही बताते हैं कि **किस फ़ीचर** या **किस ग्राहक** ने ख़र्च किया, और यह तो बिल्कुल नहीं बता सकते कि मंगलवार को बिल क्यों उछला। आपका अपना usage लॉग बता सकता है। यह पोस्ट लॉग का स्कीमा, उसे भरने वाला रैपर, हर कॉल की लागत निकालने का तरीक़ा, और निजी डेटा को बाहर रखने का तरीक़ा दिखाती है। इन आँकड़ों का क्या करें, यह कहीं और है: [हर यूज़र की लागत और SaaS कीमतें](https://broadrouter.com/hi/blog/llm-cost-per-user-saas/) और [बजट और लूप गार्ड](https://broadrouter.com/hi/blog/llm-api-spend-control/)।

## हर LLM कॉल के लिए क्या लॉग करें?

हर कोशिश की एक पंक्ति, रीट्राई समेत:

| फ़ील्ड | उदाहरण | क्यों |
| --- | --- | --- |
| `ts` | 2026-11-14T09:12:03Z | टाइम सीरीज़, घटनाओं की टाइमलाइन |
| `feature` | `support_reply` | हर फ़ीचर की लागत |
| `user_hash` | `hmac:4f1c…` | पहचान स्टोर किए बिना हर यूज़र की लागत |
| `tenant` | `acme` | B2B ऐप में हर ग्राहक की लागत |
| `model` | broadnet/deepseek-v4.1-flash | कीमत देखना, मॉडलों की तुलना |
| `prompt_tokens` | 18,240 | इनपुट की लागत |
| `cached_tokens` | 16,384 | कैश्ड इनपुट सस्ता है; [कैश रेट](https://broadrouter.com/hi/blog/cached-input-tokens-explained/) ट्रैक करें |
| `reasoning_tokens` | 612 | reasoning मॉडलों पर छिपी आउटपुट लागत |
| `completion_tokens` | 1,104 | आउटपुट की लागत (reasoning शामिल) |
| `cost_usd` | निकाली गई | वह संख्या जो फ़ाइनेंस माँगता है |
| `latency_ms`, `ttft_ms` | 4,210 / 690 | परफ़ॉर्मेंस में गिरावट |
| `status` | 200, 429, 503 | एरर और रीट्राई की दरें |
| `request_id` | `X-Request-ID` की वैल्यू | सपोर्ट टिकट और इनवॉइस विवाद |
| `prompt_version` | `support-v14` | लागत के बदलाव को प्रॉम्प्ट के बदलाव से जोड़ता है |

न प्रॉम्प्ट का टेक्स्ट, न जवाब का टेक्स्ट। वे बाद में आते हैं, और सिर्फ़ रिडैक्शन के साथ।

## हर कॉल की लागत कैसे निकालें?

usage ब्लॉक पढ़ें और हर [टोकन](https://broadrouter.com/hi/glossary/input-and-output-tokens/) प्रकार की कीमत अलग लगाएँ। BroadNet [pricing.json](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-llm-api-usage-logging&utm_content=body) में मशीन-पठनीय कीमतें प्रकाशित करता है, हर मॉडल के इनपुट, कैश्ड इनपुट और आउटपुट की प्रति-1M कीमतों के साथ:

```python
import json, urllib.request

PRICES = {m["id"]: m for m in json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))["models"]}

def call_cost(model: str, usage) -> float:
    p = PRICES[model]
    details = getattr(usage, "prompt_tokens_details", None)
    cached = (getattr(details, "cached_tokens", 0) or 0) if details else 0
    new_input = usage.prompt_tokens - cached
    return (
        new_input * (p.get("input_per_m") or 0)
        + cached * (p.get("cached_input_per_m") or p.get("input_per_m") or 0)
        + usage.completion_tokens * (p.get("output_per_m") or 0)
    ) / 1_000_000
```

प्राइस फ़ाइल को कैश करें और हर कॉल पर लाने की जगह रोज़ रीफ़्रेश करें। दो आसान ग़लतियाँ: कैश्ड टोकन को नए इनपुट की कीमत पर गिनना (लागत बढ़ा-चढ़ाकर दिखती है), और यह भूल जाना कि reasoning टोकन पहले से `completion_tokens` के अंदर हैं (उन्हें दो बार न जोड़ें)।

## लॉगिंग रैपर कैसा दिखता है?

```python
import hashlib, hmac, os, time, logging
from openai import OpenAI

log = logging.getLogger("llm.usage")
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
HASH_KEY = os.environ["USAGE_HASH_KEY"].encode()

def user_hash(user_id: str) -> str:
    return "hmac:" + hmac.new(HASH_KEY, user_id.encode(), hashlib.sha256).hexdigest()[:16]

def chat(*, feature: str, user_id: str, prompt_version: str, **kwargs):
    t0 = time.perf_counter()
    row = {"feature": feature, "user_hash": user_hash(user_id),
           "model": kwargs["model"], "prompt_version": prompt_version}
    try:
        raw = client.chat.completions.with_raw_response.create(**kwargs)
        resp = raw.parse()
        u = resp.usage
        d = getattr(u, "completion_tokens_details", None)
        row.update(
            status=200,
            request_id=raw.headers.get("x-request-id"),
            prompt_tokens=u.prompt_tokens,
            cached_tokens=getattr(getattr(u, "prompt_tokens_details", None), "cached_tokens", 0) or 0,
            reasoning_tokens=(getattr(d, "reasoning_tokens", 0) or 0) if d else 0,
            completion_tokens=u.completion_tokens,
            cost_usd=round(call_cost(kwargs["model"], u), 6),
        )
        return resp
    except Exception as e:
        row.update(status=getattr(e, "status_code", "error"),
                   request_id=getattr(getattr(e, "response", None), "headers", {}).get("x-request-id"))
        raise
    finally:
        row["latency_ms"] = int((time.perf_counter() - t0) * 1000)
        log.info("llm_call", extra={"llm": row})
```

`with_raw_response` आपको हेडर देता है, ताकि आप `X-Request-ID` रख सकें। स्ट्रीम वाले कॉल के लिए `stream_options={"include_usage": True}` जोड़ें और पंक्ति आख़िरी चंक से भरें, जैसा [SSE स्ट्रीमिंग वाली पोस्ट](https://broadrouter.com/hi/blog/llm-streaming-sse-explained/) में दिखाया है। `HASH_KEY` को गुप्त और स्थिर रखें: एक ही यूज़र हमेशा एक ही हैश बनता है, पर key के बिना हैश को उलटा नहीं जा सकता।

## लागत को यूज़र्स और फ़ीचर्स से कैसे जोड़ें?

ऊपर की पंक्तियाँ किसी भी SQL स्टोर में हों, तो बँटवारा एक क्वेरी है:

```sql
SELECT feature, model,
       count(*)                          AS calls,
       sum(cost_usd)                     AS cost,
       sum(cached_tokens)::float / nullif(sum(prompt_tokens), 0) AS cache_rate,
       avg(completion_tokens)            AS avg_out
FROM llm_calls
WHERE ts >= now() - interval '7 days'
GROUP BY feature, model
ORDER BY cost DESC;
```

हर ग्राहक की लागत के लिए `feature` की जगह `user_hash` या `tenant` लगाएँ। तीन अगले क़दम जल्दी फ़ायदा देते हैं:

1.  **लागत के हिसाब से टॉप 1% यूज़र।** अक्सर कोई एक लूप या बॉट। गिरता हुआ `cache_rate` दूसरी शुरुआती चेतावनी है; [प्रॉम्प्ट कैशिंग कैलकुलेटर](https://broadrouter.com/tools/prompt-caching-calculator/) दिखाता है कि कैश रेट का हर पॉइंट कितने का है।
2.  **हर सफल नतीजे की लागत**, हर कॉल की नहीं: अपने सफलता वाले इवेंट से जोड़ें।
3.  **रीट्राई का हिस्सा।** 429 या 5xx स्टेटस वाली पंक्तियाँ दिखाती हैं कि आप विफलताओं पर कितना ख़र्च करते हैं; देखें [429 एरर सँभालना](https://broadrouter.com/hi/blog/handle-llm-api-429-rate-limits/)।

## LLM लॉग से PII को बाहर कैसे रखें?

सबसे सुरक्षित लॉग वह है जिसमें प्रॉम्प्ट टेक्स्ट बिल्कुल न हो। जब डीबगिंग या eval के लिए टेक्स्ट चाहिए, तो ये क़दम इसी क्रम में अपनाएँ:

1.  **सैंपल करें।** टेक्स्ट कॉल के एक छोटे हिस्से और विफलताओं के लिए रखें, सब कुछ के लिए नहीं।
2.  **लिखने से पहले रिडैक्ट करें।** रिडैक्शन उसी प्रोसेस में चलाएँ जो लॉग लिखता है। बाद में रिडैक्ट करने का मतलब है कि कच्चा टेक्स्ट पहले से डिस्क पर और बैकअप में है।
3.  **डिटेक्टर की परतें लगाएँ।** स्ट्रक्चर्ड डेटा के लिए regex, नामों और पतों के लिए NER टूल।
4.  **अलग स्टोर करें।** टेक्स्ट को सख़्त एक्सेस और कम रिटेंशन वाली अलग टेबल या बकेट में रखें, `request_id` से जुड़ा हुआ।
5.  **सीक्रेट कभी लॉग न करें।** OWASP लॉगिंग चीट शीट बाहर रखे जाने वाले डेटा में एक्सेस टोकन, पासवर्ड और एन्क्रिप्शन key गिनाती है; [API key](https://broadrouter.com/hi/glossary/api-key/) भी उसी सूची में है।

एक न्यूनतम regex परत:

```python
import re
PATTERNS = [
    (re.compile(r"[\w.+-]+@[\w-]+\.[\w.-]+"), "[EMAIL]"),
    (re.compile(r"\+?\d[\d\s().-]{7,}\d"), "[PHONE]"),
    (re.compile(r"\b(?:\d[ -]?){13,19}\b"), "[CARD]"),
    (re.compile(r"\b(sk|key|bearer)[-_ ]?[A-Za-z0-9]{16,}\b", re.I), "[SECRET]"),
]
def redact(text: str) -> str:
    for pat, label in PATTERNS:
        text = pat.sub(label, text)
    return text
```

यह साफ़ मामलों को पकड़ता है और नाम, पते और कुछ भी असामान्य छोड़ देता है। [Microsoft Presidio](https://github.com/microsoft/presidio) इनके लिए एंटिटी रिकग्निशन जोड़ता है, और उसका README साफ़ कहता है कि इसकी कोई गारंटी नहीं कि वह सारी संवेदनशील जानकारी ढूँढ लेगा। चूकों के लिए योजना बनाएँ: कम रिटेंशन और सख़्त एक्सेस, किसी चूक के निकल जाने पर नुक़सान सीमित करते हैं।

## BroadNet Inference कहाँ काम आता है

BroadNet Inference, जब मॉडल रिपोर्ट करे तब कैश्ड और reasoning टोकन के साथ usage ब्लॉक लौटाता है, हर रिस्पॉन्स पर `X-Request-ID` देता है, और एक पब्लिक प्राइस फ़ाइल रखता है जिसे आप लागत निकालने के लिए लोड कर सकते हैं। उसकी तरफ़, प्रॉम्प्ट और जवाब अनुरोध के लिए प्रोसेस होते हैं और रखे नहीं जाते; वह सिर्फ़ बिना कंटेंट वाले रिकॉर्ड रखता है, जैसे समय, टोकन की संख्या और लागत ([ज़ीरो डेटा रिटेंशन कैसे काम करता है](https://broadrouter.com/hi/privacy/))। इससे किसी भी प्रॉम्प्ट टेक्स्ट की अकेली कॉपी आपके अपने लॉग बन जाते हैं, इसलिए ऊपर के रिडैक्शन नियम ही आपकी असली रिटेंशन तय करते हैं। BroadNet के चैट अनुरोधों में हर यूज़र के मेटाडेटा का कोई फ़ील्ड नहीं है, इसलिए बँटवारा आपके रैपर में होता है। हर टीम के अलग बजट के लिए अलग key इस्तेमाल करें; [key गाइड](https://broadrouter.com/hi/guides/api-keys-ip-allow-lists/) लेबल और allow-list कवर करती है।

इस विषय के मुफ़्त टूल (अंग्रेज़ी में)

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

[मुफ़्त टूल (अंग्रेज़ी में)](https://broadrouter.com/tools/)

## इस लेख के शब्द

[टोकन (token)](https://broadrouter.com/hi/glossary/token/)

टोकन टेक्स्ट की वह इकाई है जिसे लैंग्वेज मॉडल पढ़ता और लिखता है: कोई शब्द, शब्द का हिस्सा, विराम चिह्न या बाइट का क्रम, जो मॉडल का टोकनाइज़र बनाता है। LLM API इस्तेमाल को टोकन में गिनते हैं, उसी में लिमिट लगाते हैं और आम तौर पर बिल भी बनाते हैं।

[कैश्ड इनपुट टोकन (cached input tokens)](https://broadrouter.com/hi/glossary/cached-input-tokens/)

कैश्ड इनपुट टोकन वे प्रॉम्प्ट टोकन हैं जिन्हें LLM प्रोवाइडर ने हाल ही में प्रोसेस किया है और दोबारा गणना करने के बजाय कैश से फिर इस्तेमाल कर सकता है, आम तौर पर सिस्टम प्रॉम्प्ट या डॉक्यूमेंट जैसा दोहराया गया प्रीफ़िक्स। प्रोवाइडर इनका बिल नए इनपुट टोकन से कम दर पर बनाते हैं।

[ज़ीरो डेटा रिटेंशन (zero data retention, ZDR)](https://broadrouter.com/hi/glossary/zero-data-retention/)

ज़ीरो डेटा रिटेंशन (ZDR) डेटा सँभालने की एक पॉलिसी है, जिसमें AI प्रोवाइडर प्रॉम्प्ट और आउटपुट सिर्फ़ अनुरोध पूरा करने के लिए प्रोसेस करता है और बाद में वह सामग्री लॉग, कैश या ट्रेनिंग डेटा में स्टोर नहीं करता। टोकन गिनती और समय जैसे बिना सामग्री वाले रिकॉर्ड आम तौर पर फिर भी रखे जाते हैं।

[टूल कॉलिंग (tool calling)](https://broadrouter.com/hi/glossary/tool-calling/)

टूल कॉलिंग, जिसे function calling भी कहते हैं, LLM API की वह सुविधा है जिसमें मॉडल डेवलपर के तय किए किसी फ़ंक्शन को चलाने का एक स्ट्रक्चर्ड अनुरोध, JSON आर्ग्युमेंट के साथ, लौटाता है। ऐप्लिकेशन फ़ंक्शन चलाकर नतीजा वापस भेजता है; मॉडल ख़ुद कभी कोड नहीं चलाता।

[नेम्ड एंटिटी रिकग्निशन (NER)](https://broadrouter.com/hi/glossary/named-entity-recognition/)

Named entity recognition (NER) टेक्स्ट में नाम ढूँढने और हर नाम को व्यक्ति, संगठन या जगह जैसे किसी प्रकार का लेबल देने का काम है। पुराने सिस्टम हर टोकन को टैग करते हैं; LLM से अक्सर entities की सूची JSON में माँगी जाती है, जिसे फिर स्रोत टेक्स्ट से मिलाकर जाँचा जाता है।

[रेट लिमिट (rate limit)](https://broadrouter.com/hi/glossary/rate-limit/)

रेट लिमिट वह सीमा है जो कोई API तय करता है कि एक क्लाइंट किसी समय-अवधि में उसका कितना इस्तेमाल कर सकता है, जैसे प्रति मिनट अनुरोध या प्रति मिनट टोकन। सीमा से ऊपर के अनुरोध ठुकरा दिए जाते हैं, आम तौर पर HTTP 429 Too Many Requests के साथ, जब तक इस्तेमाल फिर सीमा के नीचे न आ जाए।

[स्ट्रीमिंग (streaming)](https://broadrouter.com/hi/glossary/streaming/)

स्ट्रीमिंग, लैंग्वेज मॉडल के जवाब को अंत में एक साथ लौटाने के बजाय, बनते समय ही छोटे-छोटे टुकड़ों (chunks) में लौटाने का तरीक़ा है। OpenAI-कम्पैटिबल API, अनुरोध में stream को true सेट करने पर server-sent events से स्ट्रीम करते हैं।

[API key](https://broadrouter.com/hi/glossary/api-key/)

API key एक गुप्त स्ट्रिंग है जो API कॉल करने वाले क्लाइंट को पहचानती और अधिकृत करती है। LLM API आम तौर पर इसे Authorization: Bearer हेडर में चाहते हैं, और जिसके पास भी यह key हो, वह ऐसे अनुरोध कर सकता है जिनका बिल key वाले अकाउंट पर बनता है।

## अक्सर पूछे जाने वाले सवाल

### हर यूज़र की LLM API लागत कैसे ट्रैक करूँ?

हर कॉल पर यूज़र का पहचानकर्ता लगाएँ, रिस्पॉन्स से usage ब्लॉक पढ़ें, टोकन की संख्या को अपनी प्राइस टेबल से गुणा करें, और हर कॉल की एक लॉग पंक्ति लिखें। यूज़र टैग से ग्रुप करें। ईमेल की जगह हैश किया हुआ ID इस्तेमाल करें।

### क्या पूरे प्रॉम्प्ट और जवाब लॉग करूँ?

डिफ़ॉल्ट रूप से नहीं। निजी डेटा वहीं होता है। हर कॉल के टोकन और मेटाडेटा लॉग करें, और पूरा टेक्स्ट सिर्फ़ सैंपल किए गए या फ़ेल हुए कॉल का रखें, रिडैक्शन के बाद, कम रिटेंशन अवधि के साथ।

### मेरी निकाली गई लागत प्रोवाइडर के इनवॉइस से अलग क्यों है?

आम तौर पर इसलिए कि कैश्ड टोकन को नए इनपुट की कीमत पर गिना गया, reasoning टोकन आउटपुट से छूट गए, या रीट्राई लॉग नहीं हुए। हर कोशिश लॉग करें, उन फ़ेल हुई कोशिशों समेत जिन्होंने usage लौटाया।

### स्ट्रीमिंग रिस्पॉन्स से टोकन usage कैसे मिलेगा?

stream\_options में include\_usage को true सेट करें। तब आख़िरी चंक में ख़ाली choices सूची के साथ usage ब्लॉक आता है।

### LLM लॉग के लिए कौन-सा PII रिडैक्शन टूल इस्तेमाल करूँ?

ईमेल, फ़ोन नंबर और कार्ड नंबर जैसे स्ट्रक्चर्ड डेटा के लिए regex से शुरू करें, और नामों और पतों के लिए Microsoft Presidio जैसा NER-आधारित टूल जोड़ें। Presidio का अपना README कहता है कि वह सब कुछ ढूँढने की गारंटी नहीं दे सकता।

## आगे पढ़ें

-   [ज़ीरो डेटा रिटेंशन वाला LLM API: 10 सवालों की चेकलिस्ट](https://broadrouter.com/hi/blog/zero-data-retention-llm-api-checklist/)
-   [कैश्ड इनपुट टोकन क्या हैं: LLM API का बिल कैसे घटाएँ](https://broadrouter.com/hi/blog/cached-input-tokens-explained/)
-   [LLM API में 429 एरर कैसे सँभालें: बैकऑफ़, जिटर और लिमिटर](https://broadrouter.com/hi/blog/handle-llm-api-429-rate-limits/)
-   [LLM स्ट्रीमिंग समझें: SSE चंक, डेल्टा, usage और कैंसल](https://broadrouter.com/hi/blog/llm-streaming-sse-explained/)
-   [LLM API रिस्पॉन्स कैश करके लागत घटाएँ: Python में एक्ज़ैक्ट-मैच कैश](https://broadrouter.com/hi/blog/cache-llm-responses-cut-cost/)
-   [BroadNet का GPU हार्डवेयर और सर्विंग का तरीक़ा, BroadNet के शब्दों में](https://broadrouter.com/hi/blog/broadnet-gpu-fleet-and-serving/)
-   [डॉक्यूमेंट AI वर्कफ़्लो में ह्यूमन रिव्यू को शामिल करें](https://broadrouter.com/hi/blog/document-review-queues/)
-   [गाइड: BroadNet Inference के साथ OpenAI Python SDK इस्तेमाल करें](https://broadrouter.com/hi/guides/openai-python-sdk/)
-   [गाइड: chat completions स्ट्रीम करें और टूटे कनेक्शन सँभालें](https://broadrouter.com/hi/guides/streaming-chat-completions/)
-   [गाइड: IP allow-list से API key को अपने सर्वर तक सीमित करें](https://broadrouter.com/hi/guides/api-keys-ip-allow-lists/)

इसे अपने असली वर्कलोड पर आज़माएँ। नए अकाउंट Gemma और ट्रांसक्रिप्शन के लिए US$5 के क्रेडिट से शुरू होते हैं। DeepSeek, GLM, और Qwen3.8 के लिए टॉप-अप ज़रूरी है।

[शुरू करें](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-llm-api-usage-logging&utm_content=page-cta) ·

**स्रोत**

-   [BroadNet Inference API रेफ़रंस, usage फ़ील्ड, अनुरोध ID और रिटेंशन (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-llm-api-usage-logging&utm_content=sources)
-   [BroadNet Inference की मशीन-पठनीय कीमतें (pricing.json) (अंग्रेज़ी में)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-llm-api-usage-logging&utm_content=sources)
-   [OWASP Logging Cheat Sheet, लॉग से बाहर रखने वाला डेटा](https://cheatsheetseries.owasp.org/cheatsheets/Logging_Cheat_Sheet.html)
-   [Microsoft Presidio README, PII पहचान और उसकी सीमाएँ (प्राप्त 2026-11-14)](https://github.com/microsoft/presidio)
-   [openai-python README, with\_raw\_response से रिस्पॉन्स हेडर पढ़ना](https://github.com/openai/openai-python)
