ಅಪ್‌ಲೋಡ್ ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಟ್ ಅಲ್ಲ, ಒಂದು ಜಾಬ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಪ್ರತಿ ಕ್ರಿಯೇಟ್ ಕರೆಯಲ್ಲಿ Idempotency-Key ಇಡಿ, ಆಗ ಮರುಪ್ರಯತ್ನವು ಎರಡನೇ ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಷನ್ ಅನ್ನು ರಚಿಸುವುದೂ ಬಿಲ್ ಮಾಡುವುದೂ ಸಾಧ್ಯವಿಲ್ಲ. ನಂತರ ಜಾಬ್ ಮುಗಿಯುವವರೆಗೆ ಕಾಯಿ, ಮತ್ತು ಅದೇ ID ಯಿಂದ ವಾಕ್ಯಗಳು, ಪದಗಳು ಅಥವಾ ಎಕ್ಸ್‌ಪೋರ್ಟ್ ಓದಿ.
ಫೈಲ್ ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಷನ್ VocalStack API ಮಾಡುವ ಅತ್ಯಂತ ಸರಳ ಕೆಲಸ, ಮತ್ತು ಅದು ಯಾವುದೇ ಅಸಿಂಕ್ರೋನಸ್ ಜಾಬ್‌ನ ರೂಪವನ್ನೇ ಹೊಂದಿದೆ: ಅಪ್‌ಲೋಡ್, ಕಾಯುವಿಕೆ, ಓದುವಿಕೆ. ಅಪ್‌ಲೋಡ್ ತಕ್ಷಣ ಒಂದು ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಷನ್ ಮತ್ತು ಅದರ ಜಾಬ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಆದರೆ ಇನ್ನೂ ಒಂದೇ ಪದವೂ ಇರುವುದಿಲ್ಲ. ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಜಾಬ್ ಅನ್ನು ಪೋಲ್ ಮಾಡುತ್ತಿರುವಾಗ, ಸರ್ವರ್ ಫೈಲ್ ಅನ್ನು ಆಡಿಯೊ ಚಲಿಸುವ ವೇಗಕ್ಕಿಂತ ಹಲವು ಪಟ್ಟು ವೇಗವಾಗಿ ಟ್ರಾನ್ಸ್‌ಕ್ರೈಬ್ ಮಾಡುತ್ತದೆ. ಸ್ಥಿತಿ done ಆದಾಗ, ನೀವು ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸ್ಪೀಕರ್‌ಗಳು ಮತ್ತು ಸಮಯದೊಂದಿಗೆ ವಾಕ್ಯಗಳಾಗಿ ಓದಬಹುದು, ಅಥವಾ ನಾಲ್ಕು ಸ್ವರೂಪಗಳಲ್ಲಿ ಒಂದರಲ್ಲಿ ಫೈಲ್ ಆಗಿ ಎಕ್ಸ್‌ಪೋರ್ಟ್ ಮಾಡಬಹುದು, ಮಾತನಾಡಿದ ಭಾಷೆಯಲ್ಲಾಗಲಿ ಅನುವಾದಿತ ಭಾಷೆಯಲ್ಲಾಗಲಿ.
ಈ ಆಕಾರದ ಎಲ್ಲವೂ ಯಾವುದೇ ಬ್ಯಾಚ್ API ಗೆ ಅನ್ವಯಿಸುತ್ತದೆ: ಒಂದು ID ನೀಡುವ ಕ್ರಿಯೇಟ್, ನೀವು ಪೋಲ್ ಮಾಡುವ ಸ್ಥಿತಿ, ನಂತರ ತರುವ ಫಲಿತಾಂಶ. ಫೀಲ್ಡ್ ಹೆಸರುಗಳು ಮಾತ್ರ VocalStack ಗೆ ನಿರ್ದಿಷ್ಟ; ಈ ಟ್ಯುಟೋರಿಯಲ್ TypeScript ಮತ್ತು Python SDK ಗಳೊಂದಿಗೆ, ಮತ್ತು ಸಹಾಯಕವಾದಲ್ಲಿ HTTP ಕರೆಗಳೊಂದಿಗೆ, ಇದನ್ನು ವಿವರಿಸುತ್ತದೆ.
Dashboard ನಲ್ಲಿ Developers → API keys ತೆರೆದು Read ಮತ್ತು Write ಅನುಮತಿಗಳೊಂದಿಗೆ ಒಂದು ಕೀ ರಚಿಸಿ. ಕೀ ಒಮ್ಮೆ ಮಾತ್ರ ತೋರಿಸಲಾಗುತ್ತದೆ; ಅದನ್ನು ಒಂದು ಎನ್ವಿರಾನ್ಮೆಂಟ್ ವೇರಿಯೇಬಲ್‌ಗೆ ನಕಲಿಸಿ:
export VOCALSTACK_API_KEY="<your API key>"
ಕೀ ಸರ್ವರ್‌ಗಳು ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಿಗಾಗಿ. ಬ್ರೌಸರ್‌ಗೆ ಹೋಗುವ ಯಾವುದೇ ವಸ್ತುವು ಕೀಯನ್ನೂ ಜೊತೆಗೆ ತೆಗೆದುಕೊಂಡು ಹೋಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಅದನ್ನು ಪೇಜ್ ಕೋಡ್‌ನಿಂದ ಮತ್ತು URL ಗಳಿಂದ ದೂರವಿಡಿ, ಏಕೆಂದರೆ URL ಗಳು ಲಾಗ್‌ಗಳಿಗೆ ಹೋಗುತ್ತವೆ. ಬ್ರೌಸರ್‌ನಿಂದ ಸ್ಟ್ರೀಮ್ ಮಾಡಲು, ನಿಮ್ಮ ಸರ್ವರ್ ಅದಕ್ಕಾಗಿ ರಿಯಲ್-ಟೈಮ್ ಸೆಷನ್ ರಚಿಸುತ್ತದೆ; ಅದು ಬೇರೆಯ ಟ್ಯುಟೋರಿಯಲ್ ಆಗಿದೆ.
ಪ್ರತಿ ಕರೆಯೂ ಕೀಯನ್ನು ಬೇರರ್ ಟೋಕನ್ ಆಗಿ ಬಳಸಿ ದೃಢೀಕರಿಸುತ್ತದೆ:
Authorization: Bearer vs_key_...
ಕೀ ನಿಮ್ಮ ಎನ್ವಿರಾನ್ಮೆಂಟ್‌ನಲ್ಲಿ ಇದ್ದ ಮೇಲೆ, ಮುಂದಿನ ಹೆಜ್ಜೆ ಅದನ್ನು ಕಳುಹಿಸುವ ಕ್ಲೈಂಟ್.
ಎರಡು SDK ಗಳಿವೆ. ಪ್ರತಿಯೊಂದರಲ್ಲಿ VocalStack ಎಂಬ ಒಂದೇ ಕ್ಲೈಂಟ್ ಇದೆ, ಅದರ ಮೆಥಡ್‌ಗಳನ್ನು ರಿಸೋರ್ಸ್ ಪ್ರಕಾರ ಗುಂಪು ಮಾಡಲಾಗಿದೆ: vs.transcriptions, vs.jobs, vs.recordings, vs.realtime ಮತ್ತು ಇನ್ನೂ ಕೆಲವು. TypeScript SDK Node 20 ಅಥವಾ ಹೊಸ ಆವೃತ್ತಿಯಲ್ಲಿ ಮತ್ತು ಬ್ರೌಸರ್‌ಗಳಲ್ಲಿ ಚಲಿಸುತ್ತದೆ; Python SDK asyncio ಮೇಲೆ ನಿರ್ಮಿತವಾಗಿದ್ದು Python 3.10 ಅಥವಾ ಹೊಸದು ಬೇಕು.
SDK ಗಳು npm ಅಥವಾ PyPI ನಲ್ಲಿ ಇಲ್ಲ. API ಪ್ರತಿ ಖಾತೆಗೂ ಬಿಲ್ಡ್‌ಗಳನ್ನು ನೀಡುತ್ತದೆ. ನಿಮ್ಮ ಪರಿಸರಕ್ಕೆ ಹೊಂದಿಸಿದ ಇನ್‌ಸ್ಟಾಲ್ ಆದೇಶಗಳು API ರೆಫರೆನ್ಸ್‌ನ ಕ್ವಿಕ್‌ಸ್ಟಾರ್ಟ್ ನ Install ವಿಭಾಗದಲ್ಲಿವೆ, ಮತ್ತು ಅವು ನಿಮ್ಮ ಕೀಯನ್ನು API ಹೋಸ್ಟ್‌ಗೆ ಮಾತ್ರ ಕಳುಹಿಸುತ್ತವೆ. ಏನನ್ನೂ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಲು ಬಯಸದಿದ್ದರೆ, ಕೆಳಗಿನ HTTP ಕರೆಗಳಿಗೆ curl ಮತ್ತು jq ಮಾತ್ರ ಸಾಕು.
ನೀವು ಯಾವುದನ್ನು ಆರಿಸಿದರೂ, ಮೊದಲ ಕರೆ ಅಪ್‌ಲೋಡ್.
POST /v1/transcriptions ಫೈಲ್ ಅನ್ನು multipart/form-data ಆಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ: file ಭಾಗ, ಜೊತೆಗೆ JSON ಹೊಂದಿರುವ ಐಚ್ಛಿಕ options ಭಾಗ. ಇದು 201 ನೊಂದಿಗೆ ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಷನ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಅದರ job.recordingId ಫೈಲ್‌ನಿಂದ ಮಾಡಿದ ರೆಕಾರ್ಡಿಂಗ್‌ನ ID, ಮತ್ತು ನಂತರದ ಪ್ರತಿ ಕರೆಯೂ ಆ ID ಯಿಂದಲೇ ಉಲ್ಲೇಖಿಸಲ್ಪಡುತ್ತದೆ.
ಮೊದಲ ಓಟಕ್ಕೆ ಎರಡು ಸೆಟ್ಟಿಂಗ್‌ಗಳು ಮುಖ್ಯ, ಎರಡೂ options.settings ಒಳಗೆ:
spokenLanguage: en ನಂತಹ ಕೋಡ್. ಬಿಟ್ಟರೆ ಭಾಷೆಯನ್ನು ಗುರುತಿಸಲಾಗುತ್ತದೆ. ಹೆಸರಿಸಿದರೆ ಗದ್ದಲದ ರೆಕಾರ್ಡಿಂಗ್‌ಗಳು ಮತ್ತು ಭಾರೀ ಉಚ್ಚಾರಣೆಗಳಲ್ಲಿ ನಿಖರತೆ ಸುಧಾರಿಸುತ್ತದೆ.speakerLabels: auto, on ಅಥವಾ off. on ಇದ್ದರೆ, ಪ್ರತಿ ವಾಕ್ಯಕ್ಕೆ ಸ್ಪೀಕರ್ ಸಂಖ್ಯೆ ಇರುತ್ತದೆ; auto ಇದ್ದರೆ, ಎರಡನೇ ಸ್ಪೀಕರ್ ಕೇಳಿಸಿದ ಮೇಲೆ ಮಾತ್ರ ಲೇಬಲ್‌ಗಳು ಕಾಣಿಸುತ್ತವೆ.mp3, wav, flac, ogg, m4a, mp4 ಮುಂತಾದ ಬಹುತೇಕ ಆಡಿಯೊ ಮತ್ತು ವೀಡಿಯೊ ಫೈಲ್‌ಗಳು ಸ್ವೀಕರಿಸಲ್ಪಡುತ್ತವೆ. ವೀಡಿಯೊ ತನ್ನ ಆಡಿಯೊವನ್ನು ಮಾತ್ರ ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ. ಫೈಲ್ ಸ್ವರೂಪ ನಿಖರತೆಗೆ ಹೆಚ್ಚು ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ಭಾಷಣ ಗುರುತಿಸುವಿಕೆ 16 kHz ಮೋನೊದಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಮತ್ತು ಬಂದ ತಕ್ಷಣ ಎಲ್ಲವನ್ನೂ ಅದಕ್ಕೆ ಮರುಮಾದರಿ ಮಾಡಲಾಗುತ್ತದೆ. ಒಬ್ಬ ವ್ಯಕ್ತಿ ಮಾತನಾಡುವ 48 kHz ಸ್ಟೀರಿಯೊ WAV ತನ್ನ ಹೆಚ್ಚಿನ ಬೈಟ್‌ಗಳನ್ನು ಮೌನವನ್ನು ಉತ್ತಮ ಗುಣಮಟ್ಟದಲ್ಲಿ ವಿವರಿಸಲು ಬಳಸುತ್ತದೆ. ಅದೇ ಮಾತಿನ 64 kbps ಮೋನೊ MP3 ಅಥವಾ Opus ಫೈಲ್‌ನಂತೆಯೇ ಅದು ನಿಖರವಾಗಿ ಟ್ರಾನ್ಸ್‌ಕ್ರೈಬ್ ಆಗುತ್ತದೆ, ಆದರೆ ಅದು ಸುಮಾರು ಇಪ್ಪತ್ತು ಪಟ್ಟು ದೊಡ್ಡದು, ಆದ್ದರಿಂದ ಅಪ್‌ಲೋಡ್‌ಗೂ ಇಪ್ಪತ್ತು ಪಟ್ಟು ಸಮಯ ಬೇಕು. ಅಪ್‌ಲೋಡ್ ಮೊದಲು ಪರಿವರ್ತಿಸಿದರೆ, ಮೋನೊ ಮತ್ತು ಮಧ್ಯಮ ಬಿಟ್‌ರೇಟ್ ಬದಲಾಯಿಸಲು ಯೋಗ್ಯವಾದ ಎರಡೇ ಸೆಟ್ಟಿಂಗ್‌ಗಳು.
ಪ್ರತಿ ಅಪ್‌ಲೋಡ್‌ನೊಂದಿಗೆ Idempotency-Key ಕಳುಹಿಸಿ, ಮತ್ತು ಏಕೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ. ನೆಟ್‌ವರ್ಕ್ ಟೈಮ್‌ಔಟ್ ಸರ್ವರ್ ಏನು ಮಾಡಿತು ಎಂಬುದರ ಬಗ್ಗೆ ಏನನ್ನೂ ಹೇಳುವುದಿಲ್ಲ: ಅದು ವಿನಂತಿಯನ್ನು ನೋಡದೇ ಇರಬಹುದು, ಅಥವಾ ಫೈಲ್ ಅನ್ನು ಉಳಿಸಿ ಜಾಬ್ ಅನ್ನು ಸರದಿಯಲ್ಲಿ ಇಟ್ಟು ಉತ್ತರ ಕಳೆದುಹೋಗಿರಬಹುದು. ಕುರುಡು ಮರುಪ್ರಯತ್ನವು ಎರಡನೇ ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಷನ್ ಮತ್ತು ಎರಡನೇ ಬಿಲ್ಲಿಂಗ್ ಅಪಾಯವನ್ನುಂಟುಮಾಡುತ್ತದೆ. ಕೀ ಅದನ್ನು ತಡೆಯುತ್ತದೆ. ಅದೇ ಕೀ ಮತ್ತು ಅದೇ ದೇಹದೊಂದಿಗೆ 24 ಗಂಟೆಗಳೊಳಗೆ ವಿನಂತಿ ಪುನರಾವರ್ತನೆಯಾದರೆ, ಸರ್ವರ್ ಏನನ್ನೂ ರಚಿಸದೇ ಮೊದಲ ಉತ್ತರವನ್ನೇ ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇದರಿಂದ "ಕನಿಷ್ಠ ಒಮ್ಮೆ" ಎಂಬುದು "ವಾಸ್ತವದಲ್ಲಿ ಒಮ್ಮೆ" ಆಗುತ್ತದೆ. ಆದ್ದರಿಂದ ನಿಯಮ: ಒಂದು ತಾರ್ಕಿಕ ಅಪ್‌ಲೋಡ್‌ಗೆ ಒಂದು ಕೀ, ಮೊದಲ ಪ್ರಯತ್ನದ ಮೊದಲು ರಚಿಸಿ ಪ್ರತಿ ಮರುಪ್ರಯತ್ನದಲ್ಲಿ ಮರುಬಳಸಿ. ಪ್ರತಿ ಪ್ರಯತ್ನಕ್ಕೆ ಹೊಸ ಕೀ ಬಳಸಿದರೆ, ಪ್ರತಿ ಮರುಪ್ರಯತ್ನವೂ ಹೊಸ ಅಪ್‌ಲೋಡ್ ಆಗುತ್ತದೆ, ಮತ್ತು ಹೆಡರ್ ಏನನ್ನೂ ರಕ್ಷಿಸುವುದಿಲ್ಲ.
import { VocalStack } from '@vocalstack/sdk';
const vs = new VocalStack({ baseUrl: '{{api}}', apiKey: process.env.VOCALSTACK_API_KEY });
const uploadKey = crypto.randomUUID(); // one key for this upload, however many attempts it takes
const tx = await vs.transcriptions.create(
{ file: './talk.mp3', name: 'Talk', settings: { spokenLanguage: 'en', speakerLabels: 'on' } },
{ idempotencyKey: uploadKey },
);
const recordingId = tx.job!.recordingId;
import asyncio
import os
import uuid
from vocalstack import VocalStack
async def main() -> None:
upload_key = str(uuid.uuid4()) # one key for this upload, however many attempts it takes
async with VocalStack("{{api}}", api_key=os.environ["VOCALSTACK_API_KEY"]) as vs:
tx = await vs.transcriptions.create(
file="./talk.mp3",
name="Talk",
settings={"spokenLanguage": "en", "speakerLabels": "on"},
idempotency_key=upload_key,
)
assert tx.job is not None
recording_id = tx.job.recording_id
ಅದೇ ಕರೆ curl ನೊಂದಿಗೆ:
API={{api}}
AUTH="Authorization: Bearer $VOCALSTACK_API_KEY"
UPLOAD_KEY=$(uuidgen)
REC=$(curl -sSf "$API/v1/transcriptions" -H "$AUTH" -H "Idempotency-Key: $UPLOAD_KEY" \
-F file=@talk.mp3 \
-F 'options={"name":"Talk","settings":{"spokenLanguage":"en","speakerLabels":"on"}}' \
| jq -r .job.recordingId)
201 ಯಾವುದೇ ಪದವನ್ನೂ ಟ್ರಾನ್ಸ್‌ಕ್ರೈಬ್ ಮಾಡುವ ಮೊದಲೇ ಬರುತ್ತದೆ; ನಿಮ್ಮ ಕೈಯಲ್ಲಿರುವುದು ಜಾಬ್ ID, ಆದ್ದರಿಂದ ಮುಂದಿನ ಹೆಜ್ಜೆ ಅದಕ್ಕಾಗಿ ಕಾಯುವುದು.
ಒಂದು ಜಾಬ್ queued → transcribing → done ಸ್ಥಿತಿಗಳ ಮೂಲಕ ಸಾಗುತ್ತದೆ, ಅಥವಾ failed ಸ್ಥಿತಿಯಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ, ಜೊತೆಗೆ error ಸಂದೇಶ ಮತ್ತು ಕಾರಣವನ್ನು ಯಂತ್ರ ಓದಬಹುದಾದರೆ errorCode. ನಾಲ್ಕನೇ ಸ್ಥಿತಿ cropping ಎಂದರೆ, ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನ ಟ್ರಿಮ್ ಹಂತದಲ್ಲಿರುವಂತೆ, ಯಾರಾದರೂ ಟ್ರಾನ್ಸ್‌ಕ್ರೈಬ್ ಮಾಡಬೇಕಾದ ರೆಕಾರ್ಡಿಂಗ್‌ನ ಭಾಗವನ್ನು ಆಯ್ಕೆ ಮಾಡುವವರೆಗೆ ಜಾಬ್ ತಡೆಹಿಡಿಯಲ್ಪಟ್ಟಿರುತ್ತದೆ. ಸಾಮಾನ್ಯ ಅಪ್‌ಲೋಡ್ ಎಂದೂ ಆ ಸ್ಥಿತಿಗೆ ಹೋಗುವುದಿಲ್ಲ, ಆದರೂ jobs.wait ಜಾಬ್ ಅಲ್ಲಿ ತಲುಪಿದಾಗಲೂ ಹಿಂತಿರುಗುತ್ತದೆ. GET /v1/recordings/{id}/job ಓದಿ ಸ್ಥಿತಿ done ಅಥವಾ failed ಆಗುವವರೆಗೆ.
ವೆಬ್‌ಹುಕ್‌ಗಳಿಲ್ಲ, ಅದು ಉದ್ದೇಶಪೂರ್ವಕ ವ್ಯಾಪಾರ-ವಿನಿಮಯ. ವೆಬ್‌ಹುಕ್‌ಗೆ ನಿಮ್ಮ ಕಡೆ ಸಾರ್ವಜನಿಕ HTTPS ಎಂಡ್‌ಪಾಯಿಂಟ್, ಬೇರೆ ಯಾರೂ ಅದನ್ನು ಕರೆಯದಂತೆ ಸಹಿ ಪರಿಶೀಲನೆ, ಮತ್ತು ನಿಮ್ಮ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಡೌನ್ ಆದಾಗ ಮರುಪ್ರಯತ್ನ ನೀತಿ ಬೇಕು; ಒಂದು ನಿಮಿಷ ತೆಗೆದುಕೊಳ್ಳುವ ಜಾಬ್‌ಗೆ ಇದು ಸಾಕಷ್ಟು ಹೆಚ್ಚುವರಿ ವ್ಯವಸ್ಥೆ. ಪೋಲಿಂಗ್‌ಗೆ ಇವೆಲ್ಲವೂ ಬೇಡ. ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರತಿ ಎರಡು ಸೆಕೆಂಡಿಗೆ "ಮುಗಿಯಿತೇ?" ಎಂದು ಕೇಳುತ್ತದೆ, ಹಿಂಬದಿ ಸೀಟಿನ ಮಗುವಿನಂತೆ; ಆದರೆ ಮಗುವಿಗಿಂತ ಭಿನ್ನವಾಗಿ ಅದು ಶೇಕಡಾವಾರನ್ನೂ ಪಡೆಯುತ್ತದೆ.
ಈಗಾಗಲೇ ತೆರೆದಿರುವ ವೆಬ್ ಪುಟವು ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಷನ್‌ನ ಈವೆಂಟ್ಸ್ ಸಾಕೆಟ್ ಅನ್ನು ಬದಲಿಗೆ ಅನುಸರಿಸಬಹುದು (WS /v1/transcriptions/{id}/events, ಜಾಬ್ ಮುಂದುವರಿದಂತೆ job.progress ಫ್ರೇಮ್). ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಪೋಲಿಂಗ್ ಸರಿಯಾದ ಸಾಧನ.
SDK ಗಳೇ ಪೋಲಿಂಗ್ ಮಾಡುತ್ತವೆ: vs.jobs.wait ಪ್ರತಿ 2 ಸೆಕೆಂಡಿಗೆ ಜಾಬ್ ಅನ್ನು ಓದಿ ಪ್ರತಿ ಓದನ್ನು onProgress ಗೆ ನೀಡುತ್ತದೆ (Python ನಲ್ಲಿ on_progress). ಜಾಬ್‌ನ progress ನಲ್ಲಿ pct (0 ರಿಂದ 100) ಮತ್ತು processedS ಇರುತ್ತದೆ, ಅಂದರೆ ಇಲ್ಲಿಯವರೆಗೆ ಟ್ರಾನ್ಸ್‌ಕ್ರೈಬ್ ಆದ ಮಾಧ್ಯಮದ ಸೆಕೆಂಡುಗಳು. ಕೆಳಗಿನ ಪ್ರೋಗ್ರಾಮ್‌ಗಳು ಸ್ಥಿತಿ ಅಥವಾ ಶೇಕಡಾವಾರು ಬದಲಾದಾಗ ಮಾತ್ರ ಒಂದು ಸಾಲನ್ನು ಮುದ್ರಿಸುತ್ತವೆ.
let last = '';
const job = await vs.jobs.wait(recordingId, {
onProgress: (j) => {
const line = `${j.state} ${j.progress.pct}%`;
if (line !== last) console.log((last = line));
},
});
if (job.state !== 'done') throw new Error(`transcription ${job.state}: ${job.error ?? ''}`);
last = ""
def on_progress(j) -> None:
nonlocal last
line = f"{j.state} {j.progress.pct}%"
if line != last:
last = line
print(line)
job = await vs.jobs.wait(recording_id, on_progress=on_progress)
if job.state != "done":
raise RuntimeError(f"transcription {job.state}: {job.error}")
ಗಮನಿಸಿ: wait failed ಮೇಲೆ ಎಸೆಯುವುದಿಲ್ಲ; ಅದು ಜಾಬ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ ಪರಿಶೀಲನೆಯನ್ನು ನಿಮಗೆ ಬಿಡುತ್ತದೆ. ಎರಡು ಸೆಕೆಂಡ್ ಒಂದು ಭಾಷಣಕ್ಕೆ ಸೂಕ್ತ. ಮೂರು ಗಂಟೆಯ ರೆಕಾರ್ಡಿಂಗ್ ಅಥವಾ ನೂರಾರು ಫೈಲ್‌ಗಳ ಬ್ಯಾಚ್‌ಗೆ, ಮಧ್ಯಂತರವನ್ನು (intervalMs, interval_s) ಹೆಚ್ಚಿಸಿ ಅಥವಾ ಜಾಬ್ ಮುಂದುವರಿದಂತೆ ನಿಧಾನಿಸಿ: ಮೊದಲ ಓದುಗಳು ಹೆಚ್ಚು ಹೇಳುತ್ತವೆ, ನಂತರದವು ಸರ್ವರ್ ಇನ್ನೂ ಕಾರ್ಯನಿರತವಾಗಿದೆ ಎಂದು ಹೆಚ್ಚಾಗಿ ದೃಢೀಕರಿಸುತ್ತವೆ. SDK ಇಲ್ಲದೆ, ಅದೇ ಲೂಪ್ ಅನ್ನು ಕೈಯಿಂದ ಬರೆಯಿರಿ:
while :; do
JOB=$(curl -sSf "$API/v1/recordings/$REC/job" -H "$AUTH")
STATE=$(jq -r .state <<<"$JOB")
echo "$STATE $(jq -r .progress.pct <<<"$JOB")%"
case $STATE in
done) break ;;
failed) jq -r .error <<<"$JOB" >&2; exit 1 ;;
esac
sleep 2
done
ಸ್ಥಿತಿ done ಎಂದು ಓದಿದಾಗ, ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಟ್ ಸಿದ್ಧ.
GET /v1/recordings/{id}/transcript ಇಡೀ ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಒಂದೇ ಡಾಕ್ಯುಮೆಂಟ್‌ನಲ್ಲಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ:
sentences: ಜನರಿಗೆ ತೋರಿಸಬೇಕಾದದ್ದು. ಪ್ರತಿಯೊಂದರಲ್ಲಿ text, speaker, ಮತ್ತು ಸೆಕೆಂಡುಗಳಲ್ಲಿ start ಮತ್ತು end ಇರುತ್ತವೆ.segments: ಎಂಜಿನ್‌ನ ಸಾಲುಗಳು, ಪ್ರತಿಯೊಂದಕ್ಕೂ words ನಲ್ಲಿ ಪದ-ಮಟ್ಟದ ಸಮಯಗಳಿವೆ (ಪ್ರತಿ ಪದಕ್ಕೆ text, start ಮತ್ತು end).speakers: ಪ್ರತಿ ಸ್ಪೀಕರ್ ಸಂಖ್ಯೆಗೆ ಒಂದು ನಮೂದು, ಅದರ name ಸಹಿತ.ಸ್ಪೀಕರ್‌ಗಳು 0 ರಿಂದ ಸಂಖ್ಯೆ ಪಡೆಯುತ್ತಾರೆ. speaker ಮೌಲ್ಯ -1 ಎಂದರೆ ರೆಕಾರ್ಡಿಂಗ್‌ಗೆ ಸ್ಪೀಕರ್ ಲೇಬಲ್‌ಗಳು ಆಫ್ ಆಗಿದ್ದವು. ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸ್ಪ್ಯಾನಿಷ್‌ಗೆ ಅನುವಾದಿಸಿ ಓದಲು ?lang=es ಸೇರಿಸಿ; ವಾಕ್ಯಗಳು ಆ ಭಾಷೆಯಲ್ಲಿ ಹಿಂತಿರುಗುತ್ತವೆ.
const { sentences } = await vs.recordings.transcript(recordingId);
for (const s of sentences) console.log(s.speaker >= 0 ? `[speaker ${s.speaker}] ${s.text}` : s.text);
snapshot = await vs.recordings.transcript(recording_id)
for s in snapshot.sentences:
print(f"[speaker {s.speaker}] {s.text}" if s.speaker >= 0 else s.text)
curl -sSf "$API/v1/recordings/$REC/transcript" -H "$AUTH" \
| jq -r '.sentences[] | if .speaker >= 0 then "[speaker \(.speaker)] \(.text)" else .text end'
ಎರಡು ಸಮಯ ಮಟ್ಟಗಳು ಎರಡು ಕೆಲಸಗಳಿಗೆ ಸೇವೆ ಸಲ್ಲಿಸುತ್ತವೆ. ವಾಕ್ಯಗಳು ಓದುವ ಘಟಕ, ಆದ್ದರಿಂದ ಉಪಶೀರ್ಷಿಕೆ ಅಥವಾ ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಟ್ ಪುಟ ತೋರಿಸುವುದು ಅವೇ. ಪದಗಳು ತೋರಿಸುವ ಘಟಕ, ಆದ್ದರಿಂದ ಕರಾಒಕೆ ಶೈಲಿಯ ಹೈಲೈಟ್, ಹುಡುಕಾಟ ಹಿಟ್ ಅಥವಾ ಕ್ಲಿಪ್ ಕಟ್ ಬದಲಿಗೆ segments[].words ಅನ್ನು ನಡೆಸುತ್ತವೆ. ಎಕ್ಸ್‌ಪೋರ್ಟ್ ಸ್ವರೂಪಗಳನ್ನು ವಾಕ್ಯಗಳಿಂದಲೇ ನಿರ್ಮಿಸಲಾಗುತ್ತದೆ.
GET /v1/recordings/{id}/export ನಿಜವಾದ ಫೈಲ್ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. format ಮೌಲ್ಯಗಳು srt, json, xlsx ಅಥವಾ pdf, ಮತ್ತು ಫೈಲ್‌ನಲ್ಲಿ ಯಾವುದೇ ತಿದ್ದುಪಡಿಗಳು ಸೇರಿರುತ್ತವೆ. ಅನುವಾದಿತ ಫೈಲ್‌ಗಾಗಿ lang= ಸೇರಿಸಿ: ನಂತರ ಎಕ್ಸ್‌ಪೋರ್ಟ್ ಆ ಭಾಷೆಯಲ್ಲಿ ಓದುತ್ತದೆ, ಪ್ರತಿ ವಾಕ್ಯಕ್ಕೆ ಒಂದು ಸಾಲು, ಮತ್ತು ಇನ್ನೂ ಅನುವಾದವಾಗದ ಯಾವುದೇ ವಾಕ್ಯವನ್ನು ಮೊದಲು ಅನುವಾದಿಸಲಾಗುತ್ತದೆ.
SRT ಅನ್ನು ನೋಟದಿಂದ ತಿಳಿದುಕೊಳ್ಳುವುದು ಉಪಯುಕ್ತ, ಏಕೆಂದರೆ ಅದು ಬಹುತೇಕ ಪ್ರತಿ ಪ್ಲೇಯರ್ ಒಪ್ಪುವ ಉಪಶೀರ್ಷಿಕೆ ಸ್ವರೂಪ ಮತ್ತು ಸರಳ ಪಠ್ಯ. ಫೈಲ್ ಖಾಲಿ ಸಾಲುಗಳಿಂದ ಬೇರ್ಪಟ್ಟ ಕ್ಯೂಗಳ ಪಟ್ಟಿ, ಮತ್ತು ಪ್ರತಿ ಕ್ಯೂ ಎಣಿಕೆ, ಸಮಯದ ವ್ಯಾಪ್ತಿ ಮತ್ತು ಪಠ್ಯ. ಸಮಯ ಮುದ್ರೆಗಳು ಮಿಲಿಸೆಕೆಂಡ್‌ಗೆ ಮೊದಲು ಅಲ್ಪವಿರಾಮವನ್ನು ಬಳಸುತ್ತವೆ, ಇದು ಆ ಸ್ವರೂಪ ಎಂದಿಗೂ ಬಿಟ್ಟಿರದ ಒಂದು ಫ್ರೆಂಚ್ ಅಭ್ಯಾಸ:
1
00:00:01,000 --> 00:00:04,200
Welcome, everyone. Let's get started.
ಒಂದು ವಾಕ್ಯ ಪ್ರತಿ ಕ್ಯೂಗೆ ಸರಿಯಾದ ಗಾತ್ರ: ಪ್ರತಿ ಕ್ಯೂ ತೆರೆಯಲ್ಲಿರುವ ಸಮಯದಲ್ಲಿ ಓದಬಹುದು, ಮತ್ತು ಯಾವುದೂ ಆಲೋಚನೆಯ ಮಧ್ಯದಲ್ಲಿ ಕತ್ತರಿಸುವುದಿಲ್ಲ. ರೆಕಾರ್ಡಿಂಗ್‌ನಲ್ಲಿ ಸ್ಪೀಕರ್ ಲೇಬಲ್‌ಗಳಿದ್ದರೆ, ಪ್ರತಿ ಕ್ಯೂದ ಪಠ್ಯ ಸ್ಪೀಕರ್ ಹೆಸರು ಮತ್ತು ಕೋಲನ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.
TypeScript SDK ನಲ್ಲಿ vs.recordings.export Response ಹಿಂತಿರುಗಿಸುತ್ತದೆ; ಅದರ ಬೈಟ್‌ಗಳನ್ನು arrayBuffer() ನೊಂದಿಗೆ ಓದಿ. Python ನಲ್ಲಿ ಅದು bytes ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
import { writeFile } from 'node:fs/promises';
const srt = await vs.recordings.export(recordingId, 'srt');
await writeFile('talk.srt', Buffer.from(await srt.arrayBuffer()));
const pdf = await vs.recordings.export(recordingId, 'pdf', { lang: 'es' });
await writeFile('talk.es.pdf', Buffer.from(await pdf.arrayBuffer()));
srt = await vs.recordings.export(recording_id, "srt")
with open("talk.srt", "wb") as f:
f.write(srt)
pdf = await vs.recordings.export(recording_id, "pdf", lang="es")
with open("talk.es.pdf", "wb") as f:
f.write(pdf)
asyncio.run(main())
curl -sSf "$API/v1/recordings/$REC/export?format=srt" -H "$AUTH" -o talk.srt
curl -sSf "$API/v1/recordings/$REC/export?format=pdf&lang=es" -H "$AUTH" -o talk.es.pdf
ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಷನ್ ಸಂಗ್ರಹವಾಗುವುದರಿಂದ, ಅದು ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನಲ್ಲಿ Transcriptions ಅಡಿಯಲ್ಲಿ ಕಾಣಿಸುತ್ತದೆ, ಲಿಂಕ್ ಮೂಲಕ ಹಂಚಿಕೊಳ್ಳಬಹುದು, ಮತ್ತು ನಂತರ ಎಂದಾದರೂ ಮತ್ತೆ ಓದಬಹುದು. ಅದು ಮುಖ್ಯ ಚಕ್ರ: ರಚಿಸಿ, ಕಾಯಿರಿ, ಓದಿ, ಎಕ್ಸ್‌ಪೋರ್ಟ್ ಮಾಡಿ. ಈ ಟ್ಯುಟೋರಿಯಲ್‌ನ ಉಳಿದ ಭಾಗ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಒಳಗೊಳ್ಳುತ್ತದೆ: ಈಗಾಗಲೇ ಆನ್‌ಲೈನ್‌ನಲ್ಲಿರುವ ಮೀಡಿಯಾ, ನೀವು ಎದುರಿಸುವ ದೋಷಗಳು ಮತ್ತು ಒಂದು ಫೈಲ್‌ಗೆ ಎಷ್ಟು ವೆಚ್ಚವಾಗುತ್ತದೆ.
ಮೀಡಿಯಾ ಈಗಾಗಲೇ ಆನ್‌ಲೈನ್‌ನಲ್ಲಿದ್ದರೆ, ಲಿಂಕ್ ಅನ್ನು API ಗೆ ನೀಡಿ, ಅದು ಫೈಲ್ ಅನ್ನು ತಾನೇ ತರುತ್ತದೆ: ಸಾರ್ವಜನಿಕ http(s) ವಿಳಾಸ (mp3, ವೀಡಿಯೊ, ಪಾಡ್‌ಕ್ಯಾಸ್ಟ್ ಎಪಿಸೋಡ್) ಅಥವಾ YouTube ವೀಡಿಯೊ. ಕರೆ ಅದೇ POST /v1/transcriptions, ಬಹುಭಾಗದ ಅಪ್‌ಲೋಡ್ ಬದಲು JSON ದೇಹ { "url": "..." } ಜೊತೆಗೆ, ಮತ್ತು name ಹಾಗೂ settings ಮೊದಲಿನಂತೆಯೇ. SDK ಗಳಲ್ಲಿ, vs.transcriptions.createFromUrl(url) (TypeScript) ಮತ್ತು vs.transcriptions.create(url=...) (Python) ಅದೇ ವಿನಂತಿಯನ್ನು ಮಾಡುತ್ತವೆ.
ಏನನ್ನಾದರೂ ರಚಿಸುವ ಮೊದಲು, GET /v1/transcriptions/probe?url= ಲಿಂಕ್ ಏನೆಂದು ನಿಮಗೆ ಹೇಳುತ್ತದೆ. ಅದರ kind ಮೂರರಲ್ಲಿ ಒಂದು:
file: ಕೊನೆಯುಳ್ಳ ರೆಕಾರ್ಡಿಂಗ್; ಇಲ್ಲಿ ಟ್ರಾನ್ಸ್‌ಕ್ರೈಬ್ ಮಾಡಿ.live: YouTube ಲೈವ್ ಸ್ಟ್ರೀಮ್, ಕೊನೆಯಿಲ್ಲದ ರೇಡಿಯೊ ಸ್ಟ್ರೀಮ್ ಅಥವಾ ಅಂತ್ಯವಿಲ್ಲದ HLS ಪ್ಲೇಲಿಸ್ಟ್. ಲೈವ್ ಲಿಂಕ್ ಎಂದಿಗೂ ಮುಗಿಯುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಅದನ್ನು ಫೈಲ್‌ನಂತೆ ಟ್ರಾನ್ಸ್‌ಕ್ರೈಬ್ ಮಾಡಲಾಗದು; ಬದಲಿಗೆ ಲೈವ್ ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಷನ್‌ನ ಮೂಲವಾಗಿ ಬಳಸಿ.unknown: ಸರ್ವರ್‌ಗೆ ಖಚಿತವಾಗಿ ಹೇಳಲಾಗಲಿಲ್ಲ.ಲಿಂಕ್ ಮೀಡಿಯಾವಾಗಿ ತೆರೆಯದಿದ್ದಾಗ (ಉದಾಹರಣೆಗೆ ವೆಬ್ ಪುಟ), ok false ಆಗಿರುತ್ತದೆ ಮತ್ತು problem ಒಂದು ವಾಕ್ಯದಲ್ಲಿ ಕಾರಣ ವಿವರಿಸುತ್ತದೆ. ಪ್ರೋಬ್ ಐಚ್ಛಿಕ, ಮತ್ತು ನಿಮಿಷಕ್ಕೆ 60 ಕರೆಗಳಿಗೆ ಸೀಮಿತ.
ಲಿಂಕ್ ಜಾಬ್ transcribing ಮತ್ತು done ಗೆ ಮುಂದುವರಿಯುವ ಮೊದಲು fetching ನಲ್ಲಿ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ತರುವಾಗ, progress.phase ಸರ್ವರ್ ಏನು ಮಾಡುತ್ತಿದೆ ಎಂದು ಹೇಳುತ್ತದೆ: ಬೈಟ್‌ಗಳು ಬರುತ್ತಿರುವಾಗ fetching (ಇತರ ತುದಿ ಎಷ್ಟು ಎಂದು ಹೇಳಿದರೆ fetchedBytes ಮತ್ತು fetchTotalBytes ಸಹಿತ), ಅಥವಾ ವೀಡಿಯೊದಿಂದ ಆಡಿಯೊ ಹೊರತೆಗೆಯುವಾಗ extracting. progress.phasePct ಆ ಹಂತದಲ್ಲಿ ಎಷ್ಟು ದೂರ ಹೋಗಿದೆ ಎಂದು ಹೇಳುತ್ತದೆ. ದೀರ್ಘ ವೀಡಿಯೊಗೆ ಸಮಯ ಬೇಕು, ಆದ್ದರಿಂದ ಪ್ರತಿ ಕೆಲವು ಸೆಕೆಂಡಿಗೆ ಪೋಲ್ ಮಾಡಿ; ಅದಕ್ಕಾಗಿ vs.jobs.wait intervalMs (Python ನಲ್ಲಿ interval_s) ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
const probe = await vs.transcriptions.probe(url);
if (!probe.ok) throw new Error(`that link did not open: ${probe.problem}`);
if (probe.kind === 'live') throw new Error('a live link: record it with a live transcription instead');
const linkKey = crypto.randomUUID();
const tx = await vs.transcriptions.createFromUrl(url, { name: 'From a link' }, { idempotencyKey: linkKey });
const job = await vs.jobs.wait(tx.job!.recordingId, {
intervalMs: 3000,
onProgress: (j) => {
const p = j.progress;
if (j.state === 'fetching') console.log(`${p.phase ?? 'fetching'} ${p.phasePct ?? 0}%`);
else console.log(`${j.state} ${p.pct}%`);
},
});
ಲಿಂಕ್ ಟ್ರಾನ್ಸ್‌ಕ್ರೈಬ್ ಮಾಡಿ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ ಎರಡು ಭಾಷೆಗಳಲ್ಲೂ ಮತ್ತು HTTP ನಲ್ಲೂ ಪೂರ್ಣ ಪ್ರೋಗ್ರಾಮ್ ಇದೆ. ಲಿಂಕ್‌ಗಳನ್ನು ತರುವುದು ಹೆಚ್ಚಿನ ವೈಫಲ್ಯದ ಮಾರ್ಗಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು ನಿಜವಾಗಿ ಎದುರಿಸುವ ದೋಷಗಳು ಇಲ್ಲಿವೆ.
ಪ್ರತಿ ವಿಫಲ ಕರೆಯೂ ಒಂದು JSON ಹೊದಿಕೆಯಲ್ಲಿ ಉತ್ತರಿಸುತ್ತದೆ. code ಶಾಖೆ ಮಾಡಲು ಬಳಸುವ ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು status HTTP ಸ್ಥಿತಿ; message ಜನರಿಗಾಗಿ ಮತ್ತು requestId ಬೆಂಬಲಕ್ಕಾಗಿ. data ಅಡಿಯಲ್ಲಿ, retryable ಅದೇ ವಿನಂತಿಯನ್ನು ಮತ್ತೆ ಕಳುಹಿಸುವುದು ಸಹಾಯ ಮಾಡಬಹುದೇ ಎಂದು ಹೇಳುತ್ತದೆ, ಮತ್ತು details ಕೋಡ್‌ಗೆ ಬೇಕಾದದ್ದನ್ನು ಹೊಂದಿರುತ್ತದೆ. SDK ಗಳು ಒಂದೇ ದೋಷ ಪ್ರಕಾರ VocalStackError ಅನ್ನು ಎಸೆಯುತ್ತವೆ, ಅದೇ ಫೀಲ್ಡ್‌ಗಳೊಂದಿಗೆ.
ಮೊದಲ ದಿನವೇ ನಿರ್ವಹಿಸಬೇಕಾದ ಮೂರು ಕೋಡ್‌ಗಳಿವೆ.
402 insufficient_credit: ಖಾತೆಯ ಕ್ರೆಡಿಟ್ ಮುಗಿದಿದೆ, ಮತ್ತು ಏನನ್ನೂ ಬಿಲ್ ಮಾಡಲಾಗಿಲ್ಲ. details.balance ಡಾಲರ್‌ಗಳಲ್ಲಿ ಬ್ಯಾಲೆನ್ಸ್, ಮತ್ತು details.topUpUrl ಕ್ರೆಡಿಟ್ ಸೇರಿಸುವ ಸ್ಥಳ. ವೆಚ್ಚ ಮುಂಚಿತವಾಗಿ ತಿಳಿದಿದ್ದಾಗ, ಉದಾಹರಣೆಗೆ ತಿಳಿದ ಉದ್ದದ ಫೈಲ್‌ಗೆ, details.required ಅದು ಎಷ್ಟಾಗುತ್ತಿತ್ತು ಎಂದು ಹೇಳುತ್ತದೆ.429 rate_limited: Retry-After ಸೆಕೆಂಡ್‌ಗಳು ಕಾಯಿರಿ. details.metric creates_per_hour ಆಗಿದ್ದರೆ, ನೀವು ಯೋಜನೆಯ ರಚನಾ ದರ (ಗಂಟೆಗೆ ಹೊಸ ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಷನ್‌ಗಳು) ಅನ್ನು ತಲುಪಿದ್ದೀರಿ, ಸ್ಫೋಟ ಮಿತಿ ಅಲ್ಲ; limit ಮತ್ತು resetsAt ಮಿತಿ ಎಷ್ಟು ಮತ್ತು ಅದು ಯಾವಾಗ ಮುಕ್ತವಾಗುತ್ತದೆ ಎಂದು ಹೇಳುತ್ತವೆ.503 unavailable: ಸೇವೆ ಕ್ಷಣಕಾಲ ಲಭ್ಯವಿಲ್ಲ. Retry-After ನಂತರ ವಿನಂತಿಯನ್ನು ಮತ್ತೆ ಕಳುಹಿಸಿ.SDK ಗಳು 429 ಮತ್ತು 503 ಅನ್ನು Retry-After ನಂತರ, ಡೀಫಾಲ್ಟ್ ಆಗಿ ಎರಡು ಬಾರಿ ಮರುಪ್ರಯತ್ನಿಸುತ್ತವೆ (ಕ್ಲೈಂಟ್‌ನ maxRetries / max_retries). 503 ಆದರೂ, ಎರಡು ಬಾರಿ ಕಳುಹಿಸಲು ಸುರಕ್ಷಿತವಾದ ಕರೆಗೆ ಮಾತ್ರ ಮರುಪ್ರಯತ್ನ ಆಗುತ್ತದೆ: GET, ಅಥವಾ Idempotency-Key ಹೊಂದಿರುವ ಕ್ರಿಯೇಟ್. ಕೀ ಇಲ್ಲದ ಕ್ರಿಯೇಟ್ ನಿಮಗೆ ಬಿಡಲಾಗಿದೆ, ಏಕೆಂದರೆ ಮೊದಲ ಪ್ರಯತ್ನ ಹೋಗಿದೆಯೇ ಎಂದು SDK ತಿಳಿಯಲಾರದು. ಪ್ರತಿ ಅಪ್‌ಲೋಡ್‌ಗೆ ಕೀ ಇಡಲು ಇದೇ ಪ್ರಾಯೋಗಿಕ ಕಾರಣ.
ಪ್ರತಿ ಪ್ರತಿಕ್ರಿಯೆಯೂ RateLimit-Limit, RateLimit-Remaining ಮತ್ತು RateLimit-Reset ಹೊಂದಿರುತ್ತದೆ, ಆದ್ದರಿಂದ ಬಿಡುವಿಲ್ಲದ ಪೈಪ್‌ಲೈನ್ 429 ಗೆ ಮುನ್ನವೇ ನಿಧಾನವಾಗಬಹುದು.
{
"code": "insufficient_credit",
"status": 402,
"message": "this account has no credit left; add credit to continue",
"data": {
"retryable": false,
"details": { "balance": -0.42, "required": 0.075, "currency": "usd", "plan": "payg", "topUpUrl": "https://…" }
},
"requestId": "01J…"
}
ಎಲ್ಲಾ ಕೋಡ್‌ಗಳ ಪೂರ್ಣ ಪಟ್ಟಿ ದೋಷಗಳು, ಮರುಪ್ರಯತ್ನಗಳು ಮತ್ತು ಮಿತಿಗಳು ನಲ್ಲಿದೆ. ಆ 402 ಹಣಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಏಕೈಕ ದೋಷ, ಆದ್ದರಿಂದ ಫೈಲ್ ಎಷ್ಟು ವೆಚ್ಚವಾಗುತ್ತದೆ ಎಂದು ಇಲ್ಲಿ ನೋಡಿ.
ಫೈಲ್‌ಗಳು ಪ್ರತಿ ಗಂಟೆ ಆಡಿಯೊಗೆ $0.20, ಸೆಕೆಂಡಿಗೆ ಬಿಲ್ ಮಾಡಲಾಗುತ್ತದೆ ($0.0033 ಪ್ರತಿ ನಿಮಿಷ) ಮತ್ತು 5 ನಿಮಿಷಗಳ ಕನಿಷ್ಠದೊಂದಿಗೆ: 30 ನಿಮಿಷದ ಫೈಲ್‌ಗೆ $0.10 ವೆಚ್ಚವಾಗುತ್ತದೆ. ಅದು ಹತ್ತು ಸೆಂಟ್‌ಗಳು, ಪ್ರೋಗ್ರೆಸ್ ಬಾರ್ ತುಂಬುವಾಗ ನೀವು ಕುಡಿಯುವ ಕಾಫಿಗಿಂತ ಕಡಿಮೆ. ಈ ದರ ಎಲ್ಲಾ ಯೋಜನೆಗಳಿಗೂ ಒಂದೇ, ಮತ್ತು API ಮೂಲಕವೂ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನಲ್ಲಿರುವ ದರವೇ. ಹೊಸ ಖಾತೆಗೆ ಒಂದು ಬಾರಿಯ $5 ಸೈನ್ ಅಪ್ ಕ್ರೆಡಿಟ್ ಸಿಗುತ್ತದೆ, ಮತ್ತು ಕಾರ್ಡ್ ಬೇಕಾಗಿಲ್ಲ.
ಈ ಟ್ಯುಟೋರಿಯಲ್‌ಗೆ ಮೂರು ಯೋಜನಾ ಮಿತಿಗಳು ಸಂಬಂಧಿಸಿವೆ.
GET /v1/realtime/capabilities limits.maxUploadBytes ಎಂದು ವರದಿ ಮಾಡುತ್ತದೆ. ಎರಡರಲ್ಲಿ ಚಿಕ್ಕದು ಅನ್ವಯವಾಗುತ್ತದೆ, ಮತ್ತು ಅದಕ್ಕಿಂತ ದೊಡ್ಡ ಫೈಲ್ ಯಾವುದೇ ಟ್ರಾನ್ಸ್‌ಕ್ರೈಬ್ ಆಗುವ ಮೊದಲೇ 413 ನೊಂದಿಗೆ ನಿರಾಕರಿಸಲ್ಪಡುತ್ತದೆ. ದೀರ್ಘ ರೆಕಾರ್ಡಿಂಗ್‌ಗೆ, WAV ಬದಲು ಸಂಕುಚಿತ ಮೋನೊ ಫೈಲ್ ಅಪ್‌ಲೋಡ್ ಮಾಡಲು ಇದು ಇನ್ನೊಂದು ಕಾರಣ.GET /v1/billing ನಿಮ್ಮ ಯೋಜನೆ, ಬ್ಯಾಲೆನ್ಸ್ ಮತ್ತು ಮಿತಿಗಳನ್ನು ಯಾವಾಗ ಬೇಕಾದರೂ ವರದಿ ಮಾಡುತ್ತದೆ; ಪೂರ್ಣ ಪಟ್ಟಿ ಬೆಲೆ ಪುಟ ದಲ್ಲಿದೆ.
ಇಲ್ಲಿಂದ ಮುಂದಿನ ಹೆಜ್ಜೆಗಳು: ಫೈಲ್ ಮುಗಿಯಲು ಕಾಯಲು ಸಾಧ್ಯವಾಗದಿದ್ದಾಗ ರಿಯಲ್-ಟೈಮ್‌ನಲ್ಲಿ ಆಡಿಯೊ ಸ್ಟ್ರೀಮ್ ಮಾಡುವುದು, ಅಥವಾ AI ಏಜೆಂಟ್ ಅನ್ನು MCP ಸರ್ವರ್ ಮೂಲಕ ಅದೇ ಖಾತೆಗೆ ಸಂಪರ್ಕಿಸುವುದು, ಇದರಿಂದ ಅದು ಮೇಲಿನ ಯಾವುದೇ ಕೋಡ್ ಇಲ್ಲದೆ ಟ್ರಾನ್ಸ್‌ಕ್ರೈಬ್ ಮಾಡಿ ಹುಡುಕುತ್ತದೆ.