आपके account के लिए Transcription MCP server

Hushscript का MCP server Model Context Protocol से assistant को आपकी recordings और transcripts से जोड़ता है। Browser में OAuth connection approve करें या personal access token दें। Transcription और paid actions आपके account के personal या पात्र workspace funding नियमों के अनुसार चलते हैं।

दो servers

Hushscript दो अलग MCP servers चलाता है, और ज़्यादातर पाठकों को इनमें से सिर्फ़ एक चाहिए।

https://mcp.hushscript.com/mcp वह account server है जिसके बारे में इस page के बाक़ी हिस्से में बताया गया है। यह OAuth या personal access token स्वीकार करता है। Account के काम यहीं होते हैं: upload, transcribe, edit और export।

POST https://hushscript.com/mcp अलग मुफ़्त documentation server है। न कोई account, न कोई token, न कहीं sign in करना है। यह केवल पढ़ने वाला (read-only) और anonymous है: यह न कोई account खोल सकता है, न transcription चला सकता है, न account की किसी चीज़ को छू सकता है। यह कीमतों, capabilities, page content और connect करने के तरीक़े से जुड़े सवालों का जवाब पांच tools (get_pricing, get_capabilities, how_to_connect, list_pages, get_page) से देता है। यही जानकारी तीन resources (hushscript://pricing, hushscript://capabilities, hushscript://connect) में भी मिलती है।

अगर आप ऐसे agent हैं जिसे अभी Hushscript मिला है, आपके पास token नहीं है और खर्च करने से पहले तय करना चाहते हैं कि यह आपकी ज़रूरत पूरी करता है या नहीं, तो documentation server से शुरू करें। Account connect करने के लिए तैयार होने पर इस page के बाक़ी हिस्से पर लौटें।

कनेक्ट करें

Server एक ही endpoint पर Streamable HTTP इस्तेमाल करता है:

https://mcp.hushscript.com/mcp

कोई SSE endpoint नहीं है और locally Hushscript software install नहीं करना पड़ता। Claude Code में:

claude mcp add --transport http hushscript https://mcp.hushscript.com/mcp

JSON config लेने वाले client में:

{
  "mcpServers": {
    "hushscript": {
      "type": "http",
      "url": "https://mcp.hushscript.com/mcp"
    }
  }
}

OAuth इस्तेमाल कर सकने वाला client endpoints खोजने के लिए /.well-known/oauth-authorization-server पढ़ता है। यह /oauth/register से register कर सकता है या client ID metadata document इस्तेमाल कर सकता है, फिर sign in के लिए browser window खोलता है।

आप क्या approve करते हैं

Authorization, PKCE के साथ OAuth 2.1 है। Browser window में Hushscript consent screen होती है, client का password box नहीं: यह अनुमति मांग रही application का नाम और आसान भाषा में उसके मांगे हुए काम दिखाती है, फिर आपका इंतज़ार करती है। वहां आपके approve करने तक कोई अनुमति नहीं मिलती।

Access tokens एक घंटे और refresh tokens तीस दिनों तक चलते हैं। OAuth में client आपके लिए ये credentials संभालता है; आपको config में personal access token paste नहीं करना पड़ता।

बिना browser के

OAuth connection के लिए browser में approval चाहिए। वही server सीधे personal access token भी स्वीकार करता है; connect करते समय browser का कोई step नहीं है। कोई व्यक्ति account के MCP page पर नया टोकन बनाएं से token बनाता है, उसके scopes चुनता है और तय करता है कि वह मिनट खरीद सकेगा या नहीं। Token सिर्फ़ एक बार दिखता है, hsr1:<region>:pat.<id>.<secret> जैसा होता है, और हर request में Authorization: Bearer <token> में जाता है: न OAuth round trip, न consent screen, न client registration। वही token REST API के साथ भी काम करता है।

Token ऐसे machine account का भी हो सकता है जिसका कोई human account holder नहीं है। Agent POST /v1/agent/accounts से paid signup शुरू करता है, browser में hosted Stripe Checkout पूरा करता है (वह browser ख़ुद चला सकता है), और POST /v1/agent/accounts/{signup_id}/claim पर one-time secret से account claim करके पहला token पाता है। वह token यहां किसी दूसरे token की तरह ही connect होता है। पूरे flow के लिए Agents के लिए automatic transcription देखें।

Token दूसरे tokens बना, list या revoke नहीं कर सकता। Account में अधिकतम 25 active tokens हो सकते हैं। Machine account का पहला token REST API से ख़ुद को rotate कर सकता है; इसका flow Agents के लिए automatic transcription पर है।

अनुमतियां

Connection के पास scopes का एक सेट होता है। कोई scope न बताने वाली OAuth request को default में caller के चुन सकने वाले ग्यारह scopes में से दस मिलते हैं, यानी billing के अलावा सभी। App में token बनाते समय व्यक्ति scopes चुनता है। Machine account के पहले token में सिर्फ़ transcripts:read, transcripts:write, transcribe, account:read, export, billing और self-rotation के लिए अलग pat:rotate scope होता है। Account claim होने पर दोनों billing switches enabled हो जाते हैं; व्यक्ति के बनाए token के लिए इन्हें अलग से enable करना होता है। Scopes पता होने पर server उनसे मेल खाते tools advertise करता है; backend हर call पर उन्हें लागू करता है।

billing हर तरह से अपवाद है। यह कभी अपने-आप grant नहीं होता, consent screen approval से पहले आपको चेतावनी देती है, और purchase tool के लिए token का billing flag और account-wide billing switch दोनों enabled होने चाहिए। pat:rotate को OAuth request या app के token form में नहीं चुन सकते।

Tools क्या काम करते हैं

56 tools, जिन चीज़ों पर वे काम करते हैं उनके अनुसार समूहों में:

export_transcript से TXT, SRT, VTT, Markdown या JSON मिलता है। पूरे 21 export formats app में हैं।

Tools के अलावा server connect होने पर तीन resources और एक instructions string publish करता है: minute packs, credit और scope model, और पूरा error-code catalog, ताकि client कोई call करने से पहले नियम पढ़ सके। Pages में list लौटाने वाले tools में limit और opaque cursor दिया जाता है, जो पिछले page के next_cursor से मिलता है; list_packs और list_payment_methods अपनी lists बिना cursor के लौटाते हैं।

MCP uploads में तैयार audio भेजा जाता है। Local video के लिए पहले अपने device पर उसका audio तैयार करें; transcribe_from_url supported audio links server-side fetch करता है और video links import नहीं करता। MCP से शुरू jobs standard mode में चलते हैं: उनके transcripts account की retention setting के अनुसार सहेजे जाते हैं। एक बार के लिए private mode app में उपलब्ध है, MCP tokens से नहीं।

उदाहरण

OAuth flow इस्तेमाल करने वाले client को सामान्य MCP session मिलता है और वह यह सब सीधे नहीं देखता: उसका SDK अंदर JSON-RPC बनाता है। Token वाला client हाथ से भी यही protocol भेजता है, और दोनों स्थितियों में यह debugging में मदद करता है।

Token को सीधे request में डालकर connect करें, initialize के अलावा कोई handshake नहीं चाहिए:

curl -s https://mcp.hushscript.com/mcp \
  -H "Authorization: Bearer hsr1:us:pat.4f2a1c.9e7b3d2a5c8f1e6b4a0d7c3f2e1b9a8d" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {
      "protocolVersion": "2025-06-18",
      "capabilities": {},
      "clientInfo": { "name": "example-client", "version": "1.0.0" }
    }
  }'

Token के scopes के अंतर्गत आने वाला हर tool देखने के लिए वही request अलग body के साथ फिर भेजें:

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/list"
}

हर entry में name, description और JSON Schema inputSchema होता है, जो ऊपर दिए समूहों से मेल खाता है। Tool call ऐसा दिखता है; यहां create_upload credit reserve करके upload शुरू करता है:

{
  "jsonrpc": "2.0",
  "id": 3,
  "method": "tools/call",
  "params": {
    "name": "create_upload",
    "arguments": {
      "size_bytes": 52428800,
      "duration_seconds": 1800,
      "title": "Team standup 2026-09-10",
      "transcription_options": { "speaker_detection": true }
    }
  }
}

create_upload जैसे structured tools stringified JSON वाला content text block लौटाते हैं। उदाहरण:

{
  "content": [
    {
      "type": "text",
      "text": "{\n  \"job_id\": \"job_8f3a1c2b9e\",\n  \"balance_seconds\": 5400,\n  \"held_seconds\": 1800,\n  \"upload\": {\n    \"part_size_bytes\": 33554432,\n    \"total_parts\": 2,\n    \"part_urls\": [\n      { \"n\": 1, \"url\": \"https://...\" }\n    ],\n    \"next_part_number\": 2\n  }\n}"
    }
  ]
}

ऊपर का response upload fields दिखाता है; पूरे response में limits, funding और state भी होते हैं। उन URLs पर bytes upload करें, हर part के ETag के साथ complete_upload call करें, फिर get_job को उसकी state done होने तक poll करें। नीचे के structured examples अंदरूनी JSON सीधे, पहले से parsed रूप में दिखाते हैं। इनमें {"jsonrpc":"2.0","id":...} request wrapper नहीं है क्योंकि वह नहीं बदलता: सिर्फ़ name और arguments बदलते हैं।

export_transcript rendered format को text के रूप में लौटाता है, और download_account_export_chunk raw bytes को base64 text में encode करके लौटाता है। Result के text को JSON के रूप में सिर्फ़ तब parse करें जब tool structured data लौटाता हो।

Transcripts list करना और पढ़ना:

{
  "name": "list_transcripts",
  "arguments": { "limit": 5 }
}

{
  "transcripts": [
    {
      "id": "t_9c2b7f10",
      "title": "Team standup 2026-09-10",
      "language_detected": "en",
      "duration_seconds": 1800,
      "tags": ["standup"],
      "insights_state": "none"
    }
  ],
  "next_cursor": null
}

Insights generate करना किसी transcript की पहली call पर मुफ़्त है। यह example नई generation शुरू होने के बाद का balance दिखाता है; reused, false है:

{
  "name": "generate_insights",
  "arguments": { "id": "t_9c2b7f10" }
}

{
  "ok": true,
  "reused": false,
  "balance_seconds": 5400,
  "held_seconds": 0
}

मिनट खरीदना: idempotency_key ज़रूरी है ताकि response खोने के बाद retry करने पर दोबारा charge न लगे:

{
  "name": "purchase_pack",
  "arguments": {
    "pack": "300min",
    "payment_method_id": "pm_1PxYzABC",
    "idempotency_key": "agent-2026-09-11-refill-01"
  }
}

{
  "status": "ok",
  "balance_seconds": 23400
}

Resources बिना tool call के जवाब देते हैं; resources/read में तीन URIs में से एक दिया जाता है:

{
  "jsonrpc": "2.0",
  "id": 9,
  "method": "resources/read",
  "params": { "uri": "hushscript://pricing" }
}

छोटा response (resource का स्पष्टीकरण देने वाला note हटा दिया गया है):

{
  "contents": [
    {
      "uri": "hushscript://pricing",
      "mimeType": "application/json",
      "text": "{\"packs\":[{\"id\":\"45min\",\"minutes\":45},{\"id\":\"300min\",\"minutes\":300},{\"id\":\"900min\",\"minutes\":900},{\"id\":\"1800min\",\"minutes\":1800},{\"id\":\"6000min\",\"minutes\":6000}]}"
    }
  ]
}

Packs की वर्तमान amounts और currencies के लिए list_packs इस्तेमाल करें।

हर backend failure के साथ स्थिर slug और numeric code होता है, वही {"error": "<slug>", "code": <number>} body जो hushscript://error-codes में documented है। Tool call वही slug और code raw error object के बजाय पढ़ने योग्य message में दिखाती है, और throw करने के बजाय result को isError से flag करती है:

{
  "content": [
    {
      "type": "text",
      "text": "Not enough transcription credit. This job needs 1800 seconds and the balance is 900 seconds. Top up at https://app.hushscript.com/billing (insufficient_balance, E3001)"
    }
  ],
  "isError": true
}

किन कामों में मिनट लगते हैं

Account data पढ़ने में transcription minutes खर्च नहीं होते। Paid actions की rates app जैसी ही हैं। आम तौर पर इनके लिए personal prepaid minutes इस्तेमाल होते हैं; workspace transcription में Teams pool इस्तेमाल हो सकता है अगर active pool अकेले पूरे job का खर्च उठा सके और कोई translation target न चुना गया हो। Translation targets वाला job या imported audio URL personal minutes इस्तेमाल करता है। Funding से transcript की कस्टडी नहीं बदलती।

पात्र personal accounts को card verification के बाद 30 मुफ़्त मिनट मिलते हैं; machine account signup पर खरीदे pack से शुरू होता है।

• Recording transcribe करने में उसकी duration जितने मिनट लगते हैं। Medical mode 100% जोड़ता है, और हर translation target 25% जोड़ता है। Multichannel चालू होने पर हर audio channel अलग से बिल होता है, इसलिए stereo file दो बार गिनी जाती है।
• Insights: हर transcript की पहली generation मुफ़्त है। बाद में regenerate करने पर मूल transcript से recording की duration का 40%, या साफ़-सुथरे version से 30% लगता है। Regeneration में सदस्य के personal minutes लगते हैं, भले ही transcription का भुगतान workspace pool से हुआ हो।
• Transcript दोबारा translate करने में हर भाषा के लिए उसकी duration का 25% लगता है, और यह overwrite करता है: जिन भाषाओं के लिए call charge करता है, उनके अनुवाद की हाथ से edited copy मिट जाती है और वापस नहीं मिल सकती।
• purchase_pack सफल होने पर पात्र saved card को तुरंत charge करता है। इसके लिए billing scope, token का अपना billing flag और account-wide billing switch चाहिए। यह personal balance में मिनट जोड़ता है, Teams pool में नहीं।
• add_payment_method का कोई खर्च नहीं है। यह Stripe Checkout link लौटाता है जो बिना charge किए account में card सहेजता है; इसे एक बार browser में पूरा करें (agent अपना browser चला सकता है)। बाद में purchase_pack off-session charge की कोशिश करता है; decline या issuer challenge पर अधूरे page के बजाय अलग error code मिलता है।

Packs देखने के लिए कीमतें देखें।

Review और revoke करना

जिस account में आप sign in कर सकते हैं, उसके OAuth connections account के MCP page पर कनेक्टेड ऐप्स में client और scopes के साथ दिखते हैं। Tokens भी वहीं listed हैं; किसी token को revoke करने से उसकी calls बंद हो जाती हैं। Client config हटाने से सिर्फ़ उस client की requests रुकती हैं। Machine account में इस्तेमाल करने योग्य login mailbox नहीं होता, इसलिए उसका token agent account flow से ख़ुद को rotate करता है।

सीमाएं

Human-account tokens से हर token पर प्रति मिनट 1,200 requests की अनुमति है। Agent account के tokens की lineage सभी rotations में यही budget साझा करती है। Token से Stripe call करने वाले billing routes पर प्रति account प्रति मिनट 60 requests की साझा सीमा है: card setup, purchase, default-card changes, card removal और card-list cache misses। Agent-account purchases और human-account token purchases की सीमा प्रति account हर rolling 24 घंटे में तीन attempts है। Paid agent signup भी गिना जाता है, और attempt reserve होने के बाद failures भी; human browser-session purchases इससे बाहर हैं। Cap के कारण refusal पर HTTP 429 / code 4038 agent_purchase_capped मिलता है, जो सामान्य HTTP 429 / code 5000 rate_limited से अलग है। दोनों में Retry-After मिलता है।

OAuth authorization और completion प्रति address 30-per-minute bucket साझा करते हैं। Registration का अपना 30-per-minute bucket है; /oauth/token का अलग 600-per-minute bucket है। हर bucket का key एक IPv4 address या एक IPv6 /64 होता है। Raw-token introspection cache misses के लिए उसी key पर एक और 30-per-minute bucket है; यह हर MCP tool call की सीमा नहीं है।