diff --git a/assets/images/gladiaflow-home.png b/assets/images/gladiaflow-home.png
new file mode 100644
index 0000000..398cd55
Binary files /dev/null and b/assets/images/gladiaflow-home.png differ
diff --git a/chapters/how-to-use-gladia/benchmarking.mdx b/chapters/how-to-use-gladia/benchmarking.mdx
index 36f9eff..3cc14d8 100644
--- a/chapters/how-to-use-gladia/benchmarking.mdx
+++ b/chapters/how-to-use-gladia/benchmarking.mdx
@@ -1,176 +1,64 @@
---
title: Benchmarking
-description: A practical guide to benchmarking speech-to-text accuracy — from defining goals to choosing datasets, normalizing transcripts, computing WER, and interpreting results.
+description: "A clear 5-step method to compare speech-to-text accuracy fairly"
---
-Benchmarking speech-to-text systems is easy to get wrong.
-Small methodology changes can produce large swings in reported quality, which makes comparisons misleading.
+Use one dataset with human ground truth, and the same normalization before comparing providers. Otherwise scores are not comparable.
-## Benchmarking at a glance
+## Methodology
-
-
- Decide what "good" means for your product before comparing systems.
-
-
- Normalize both references and predictions before computing WER.
-
-
- Measure substitutions, deletions, and insertions on normalized text.
-
-
- Benchmark on audio that matches your real traffic and target users.
-
-
- Look beyond one average score and inspect meaningful slices.
-
-
+
+
+ Use production audio that matches your traffic: noise, overlap, accents, and domains. Keep it under a DPA for the eval window, then flush it.
+
-## 0. Define your evaluation goal
+
+ Create independent ground truth. Do not score providers against each other's transcripts.
+
-Before comparing providers and models, the first step is to define which aspects of performance matter most for your use case.
+
+ Transcribe the same audio with every provider so the comparison is fair.
+
-Below are examples of performance aspects that would be more weighted for domain applications of speech to text:
+
+ Normalize reference and predictions with the same pipeline before WER, so `Mr.` / `Mister` and `$50` / `fifty dollars` mismatches does not count as errors.
-- Accuracy on noisy backgrounds: for contact centers, telephony, and field recordings.
-- Speaker diarization quality: for meeting assistants and multi-speaker calls.
-- Named entity accuracy: for workflows that extract people, organizations, phone numbers, or addresses.
-- Domain-specific vocabulary handling: for medical, legal, or financial transcription.
-- Timestamp accuracy: for media workflows that need readable, well-timed captions.
-- Filler-word handling: for agentic workflows .
+
+ Open-source text normalization for fair WER scoring
+
-Those choices shape every downstream decision: which dataset to use, which normalization rules to apply, and which metrics to report.
+ ```python
+ from normalization import load_pipeline
+ pipeline = load_pipeline("gladia-3", language="en")
+ normalized_reference = pipeline.normalize(reference)
+ normalized_prediction = pipeline.normalize(prediction)
+ ```
+
-If your benchmark does not reflect your real traffic, the result will not tell you much about production performance.
+
+ Compute WER (and NER where it matters), then inspect where critical details fail: names, numbers, acronyms, noisy slices.
-## 1. Normalize transcripts before computing WER
+ ```text
+ WER = (S + D + I) / N
+ ```
-Normalization removes surface-form differences (casing, abbreviations, numeric rendering) so you compare apples to apples when judging transcription output.
+ Lower is better. Do not stop at one average score.
+
+
-| Reference | Prediction | Why raw WER is wrong |
-|-----------|------------|----------------------|
-| `It's $50` | `it is fifty dollars` | Contraction and currency formatting differ, but the semantic content is the same. |
-| `Meet at Point 14` | `meet at point fourteen` | The normalization should preserve the numbered entity instead of collapsing it into an unrelated form. |
-| `Mr. Smith joined at 3:00 PM` | `mister smith joined at 3 pm` | Honorific and timestamp formatting differ, but the transcript content is equivalent. |
+## Before you start
-One common limitation is "Whisper-style normalization" (OpenAI, 2022): implemented in packages like [`whisper-normalizer`](https://pypi.org/project/whisper-normalizer/). It does not affect numbers, and applies aggressive lowercasing and punctuation stripping.
-
-Gladia's recommended approach is [`gladia-normalization`](https://github.com/gladiaio/normalization), our open-source library designed for transcript evaluation:
-
-- `It's $50` -> `it is 50 dollars`
-- `Meet at Point 14` -> `meet at point 14`
-- `Mr. Smith joined at 3:00 PM` -> `mister smith joined at 3 pm`
-
-
- Open-source transcript normalization library used before WER computation.
-
-
-```python
-from normalization import load_pipeline
-
-pipeline = load_pipeline("gladia-3", language="en")
-
-reference = "Meet at Point 14. It's $50 at 3:00 PM."
-prediction = "meet at point fourteen it is fifty dollars at 3 pm"
-
-normalized_reference = pipeline.normalize(reference)
-normalized_prediction = pipeline.normalize(prediction)
-```
-
-
- Always apply the same normalization pipeline to both the reference transcript and every hypothesis output you compare. Changing the normalization rules between references invalidates the results.
-
-
-## 2. Compute WER correctly
-
-Word Error Rate measures the edit distance between a reference transcript and a predicted transcript at the word level.
-
-The standard formula is:
-
-```text
-WER = (S + D + I) / N
-```
-
-Where:
-
-- `S` = substitutions
-- `D` = deletions
-- `I` = insertions
-- `N` = number of words in the reference transcript
-
-Lower is better. In practice:
-
-1. Prepare a reference transcript for each audio sample.
-2. Run each provider on the exact same audio.
-3. Normalize both the reference and each prediction with the same pipeline.
-4. Compute WER on the normalized outputs.
-5. Aggregate results across the full dataset.
-
-
- Do not compute WER on raw transcripts if providers format numbers, punctuation, abbreviations, or casing differently. That mostly measures formatting conventions, not recognition quality.
-
-
-
- Inspect your reference transcripts carefully before computing WER. If a
- reference contains text that is not actually present in the audio, for
- example an intro such as "this audio is a recording of...", it can make WER
- look much worse across all providers.
-
-
-## 3. Choose a representative dataset
-
-Start from your [evaluation goal](#1-define-your-evaluation-goal): the right dataset depends on the use case and traffic shape you want to measure.
-
-A good benchmark dataset should look as close as possible to your real production audio. If the audio in the benchmark does not match what you actually process, the results will not tell you much.
-
-When choosing your dataset, make sure it matches your real audio on:
-
-- Language: the target language, accents, and whether speakers switch languages.
-- Audio quality: telephony, browser microphone, studio recordings, noisy field audio, overlapping speech, or compressed audio.
-- Topics: medical, operational, legal, financial, customer support, or any other domain you care about.
-- Important words: numbers, names, acronyms, product names, addresses, or domain-specific terminology.
-- Interaction style: single-speaker dictation, calls, meetings, interviews, or long-form recordings.
-
-Use transcripts that are strong enough to serve as ground truth. When possible, combine public datasets for comparability with private in-domain datasets that reflect your real traffic.
-
-Typical failure cases:
-
-- Benchmarking call-center audio with clean podcast recordings overestimates real-world performance.
-- Benchmarking English-only speech does not capture code-switching traffic.
-- Benchmarking short clips can hide failures that appear on long recordings with multiple speakers.
-
-
- Your favorite LLM with internet access can be very effective at finding
- public datasets that match your use case.
-
-
-For a broader methodology view, see [this benchmark guide](/chapters/how-to-use-gladia/benchmarking), especially the evaluation-goal section above when mapping use cases to dataset types.
-
-## 4. Interpret results carefully
-
-Do not stop at a single WER number. Review:
-
-- overall average WER
-- median WER and spread across files
-- breakdowns by language, domain, or audio condition
-- failure modes on proper nouns, acronyms, and numbers
-- whether differences are consistent or concentrated in a few hard samples
-
-Two systems can post similar average WER while failing on different error classes. Separate statistically meaningful gaps from noise introduced by dataset composition or normalization choices.
-
-If two systems are close, inspect actual transcript examples before drawing strong conclusions.
+Decide what "good" means for your product (noise, diarization, entities, domain vocab, timestamps). If the dataset does not look like your traffic, the score will not predict production quality.
## Common pitfalls
-- Comparing providers on different datasets
-- Using low-quality or inconsistent ground truth
-- Treating punctuation and formatting differences as recognition errors
-- Drawing conclusions from too few samples
-- Reporting one average score without any slice analysis
-- Not inspecting the reference transcript: if it contains text not present in the audio, for example an intro like "this audio is a recording of...", it will inflate WER across all providers
-- Not experimenting with provider configurations: for example, using Gladia's [custom vocabulary](/chapters/audio-intelligence/custom-vocabulary) to improve proper noun accuracy, then comparing against the ground truth
+- Different datasets per provider
+- Weak ground truth
+- Counting formatting as recognition errors
+- Too few samples, or a wrong distribution of your real audio traffic diversity
+- Reference text that is not in the audio
diff --git a/chapters/how-to-use-gladia/cli.mdx b/chapters/how-to-use-gladia/cli.mdx
new file mode 100644
index 0000000..b68e95c
--- /dev/null
+++ b/chapters/how-to-use-gladia/cli.mdx
@@ -0,0 +1,165 @@
+---
+title: CLI
+description: "Transcribe audio from your terminal with one install and one command."
+---
+
+The Gladia CLI wraps the [speech-to-text API](/chapters/pre-recorded-stt/quickstart) for terminals and shell scripts.
+
+
+ Get your API key from the [Gladia dashboard](https://app.gladia.io/apikeys) before your first transcription.
+
+
+## Why use the CLI ?
+
+- **One command**: install, set your key, run `gladia transcribe audio.mp3`
+- **Flexible output**: plain text, JSON, SRT, or VTT to stdout
+- **Set up features**: diarization, languages, and model selection (`solaria-1`, `solaria-3`)
+- **Files or URLs**: local recordings or remote links
+- **Pipe-friendly**: machine-readable output for scripts and CI
+
+## Install
+
+```bash
+# macOS & Linux
+curl -fsSL https://github.com/gladiaio/gladia-cli/releases/latest/download/install.sh | sh
+
+# Windows (PowerShell)
+powershell -c "irm https://github.com/gladiaio/gladia-cli/releases/latest/download/install.ps1 | iex"
+```
+
+Other platforms and binaries: [GitHub releases](https://github.com/gladiaio/gladia-cli/releases).
+
+### API key setup
+
+```bash
+export GLADIA_API_KEY=your_key # 1. environment variable
+gladia auth set your_key # 2. saved to ~/.gladia (mode 0600)
+gladia transcribe meeting.wav --gladia-key your_key # 3. per-command flag
+```
+
+## Quick start
+
+```bash
+gladia transcribe meeting.wav # transcript to stdout
+gladia transcribe podcast.mp3 -o srt # subtitles
+gladia transcribe call.wav --diarize # who spoke when
+gladia languages # supported language codes
+```
+
+## Common workflows
+
+```bash
+# Local file or remote URL
+gladia transcribe meeting.wav
+gladia transcribe https://example.com/audio.mp3 -o json
+
+# Narrow language detection
+gladia transcribe podcast.mp3 --language en,fr,de
+
+# Mixed-language audio
+gladia transcribe mixed.mp3 --code-switching --language en,fr
+
+# Diarization as subtitles
+gladia transcribe call.wav --diarize -o srt
+
+# Pick a model
+gladia transcribe podcast.mp3 --model solaria-3 --language en
+
+# Pipe into a script
+gladia transcribe interview.mp3 -o json | jq '.transcription'
+```
+
+## Commands
+
+| Command | Description |
+| --- | --- |
+| `transcribe ` | Transcribe an audio file or URL |
+| `auth set ` | Save API key to `~/.gladia` |
+| `languages` | List supported ISO 639-1 codes |
+| `completion ` | Generate shell tab completion (bash, zsh, fish, powershell) |
+
+## Output formats
+
+Use `-o` or `--output`:
+
+| Format | Description |
+| --- | --- |
+| `text` | Plain transcript (default) |
+| `json` | Structured JSON transcript |
+| `json-full` | Full API response as JSON |
+| `srt` | SubRip subtitles |
+| `vtt` | WebVTT subtitles |
+
+## Transcription options
+
+| Flag | Default | Description |
+| --- | --- | --- |
+| `-o`, `--output` | `text` | `text`, `json`, `json-full`, `srt`, `vtt` |
+| `--language` | | Expected language(s), comma-separated (`en` or `en,fr,de`) |
+| `--cs`, `--code-switching` | off | Re-detect language per utterance (`solaria-1` only) |
+| `--diarize` | off | Identify speakers |
+| `--model` | | `solaria-1` or `solaria-3`. Solaria-3 accepts one `--language` (`en`, `fr`, `de`, `es`, or `it`) and no code switching. |
+| `-v`, `--verbose` | off | Show progress while polling |
+
+**Global flag**: `--gladia-key` (if not set via env or `~/.gladia`).
+
+### Language
+
+| Goal | Command |
+| --- | --- |
+| Auto-detect | `gladia transcribe ` |
+| Constrain detection | `--language en,fr,de` |
+| Code switching | `--code-switching` (optional `--language` hints) |
+
+- **`--language`**: limits which languages Gladia considers (hint list, not per-utterance switching).
+- **`--code-switching`**: detects language per utterance. Not available with `solaria-3`.
+
+### Diarization
+
+Use `--diarize` for who spoke when (e.g. `Speaker 0: …`).
+
+```bash
+gladia transcribe meeting.wav --diarize
+gladia transcribe panel.mp3 --diarize -o srt
+```
+
+## Shell completion
+
+The installer can set up tab completion. To skip the prompt in CI, set `GLADIA_NO_COMPLETION_PROMPT=1`.
+
+```bash
+# bash
+source <(gladia completion bash)
+
+# zsh
+mkdir -p ~/.zsh/completions
+gladia completion zsh > ~/.zsh/completions/_gladia
+
+# fish
+mkdir -p ~/.config/fish/completions
+gladia completion fish > ~/.config/fish/completions/gladia.fish
+```
+
+See `gladia completion --help` for full instructions.
+
+## Next steps
+
+
+
+ Create an API key on the Gladia dashboard
+
+
+ Source code, issues, and releases
+
+
+ Transcription features reference
+
+
diff --git a/chapters/how-to-use-gladia/gladia-flow.mdx b/chapters/how-to-use-gladia/gladia-flow.mdx
new file mode 100644
index 0000000..e4b074d
--- /dev/null
+++ b/chapters/how-to-use-gladia/gladia-flow.mdx
@@ -0,0 +1,54 @@
+---
+title: GladiaFlow
+description: "Real-time voice dictation for your desktop."
+---
+
+[GladiaFlow](https://www.gladia.io/gladiaflow) is our open-source desktop app for macOS and Windows.
+
+Hold a hotkey, speak, and text is pasted into the focused app (Slack, Notes, or Notion for example)
+
+
+
+The app is free (MIT). Usage is billed on your Gladia API key.
+
+
+
+ 
+
+
+## What you get
+
+- **Dictate anywhere**: any focused text field
+- **Real-time streaming**: partials and finals as you speak
+- **100+ languages**: auto-detect and mid-sentence [code switching](/chapters/language/code-switching)
+- **Custom vocabulary**: names, acronyms, domain terms
+- **Push-to-talk or toggle**: configurable global hotkey
+- **Open source**: [GitHub](https://github.com/gladiaio/gladiaflow)
+
+## Getting started
+
+
+
+ Use the [GladiaFlow product page](https://www.gladia.io/gladiaflow), or install from the [latest GitHub release](https://github.com/gladiaio/gladiaflow/releases/latest):
+
+ - **macOS**: universal DMG (Intel + Apple Silicon)
+ - **Windows**: NSIS installer (`.exe`)
+
+
+
+ Copy a key from the [Gladia dashboard](https://app.gladia.io/apikeys).
+
+
+
+ Open GladiaFlow, paste your API key, grant microphone (and on macOS, Accessibility) permissions, then hold the hotkey and speak.
+
+ | Platform | Default trigger |
+ | --- | --- |
+ | macOS | Fn (Globe) |
+ | Windows | Ctrl + Space |
+
+
+
+
+ The app is free. Transcription is pay-as-you-go on the same Gladia key you use for API or SDK usage.
+
diff --git a/chapters/how-to-use-gladia/playground.mdx b/chapters/how-to-use-gladia/playground.mdx
index 6e4d8bf..a20c517 100644
--- a/chapters/how-to-use-gladia/playground.mdx
+++ b/chapters/how-to-use-gladia/playground.mdx
@@ -1,9 +1,13 @@
---
title: Playground
-description: "Use the Gladia app to transcribe your audio"
+description: "Test Gladia models and features in the browser before you integrate"
mode: "wide"
---
import GettingStartedPlayground from "/snippets/getting-started-playground.mdx";
-
\ No newline at end of file
+
+
+## Test models before integrating
+
+Try the features you need (e.g. diarization or NER) and compare [Solaria-3 vs Solaria-1](/chapters/introduction/models) on your audio. Check both the readable transcript and the JSON tab.
diff --git a/chapters/how-to-use-gladia/sdk.mdx b/chapters/how-to-use-gladia/sdk.mdx
new file mode 100644
index 0000000..f12ee70
--- /dev/null
+++ b/chapters/how-to-use-gladia/sdk.mdx
@@ -0,0 +1,205 @@
+---
+title: SDK
+description: "Transcribe audio in a few lines with the official Gladia SDKs"
+---
+
+Ship transcription in minutes. The official SDKs handle upload, jobs, live WebSockets, and retries so you write product code, not plumbing.
+
+
+
+ `npm install @gladiaio/sdk`
+
+
+ `pip install gladiaio-sdk`
+
+
+
+## Install
+
+
+
+```bash JavaScript
+npm install @gladiaio/sdk
+```
+
+```bash Python
+pip install gladiaio-sdk
+```
+
+
+
+Get an API key from the [Gladia dashboard](https://app.gladia.io/apikeys), or set `GLADIA_API_KEY`.
+
+## Pre-recorded in 3 lines
+
+Pass a local file or a URL. One call uploads, runs the job, and returns the result.
+
+
+
+```javascript JavaScript
+import { GladiaClient } from "@gladiaio/sdk";
+
+const gladia = new GladiaClient({ apiKey: "YOUR_GLADIA_API_KEY" });
+const result = await gladia.preRecorded().transcribe("audio.mp3");
+
+console.log(result);
+```
+
+```python Python
+from gladiaio_sdk import GladiaClient
+
+gladia = GladiaClient(api_key="YOUR_GLADIA_API_KEY").prerecorded()
+result = gladia.transcribe("audio.mp3")
+
+print(result)
+```
+
+
+
+Add options when you need them:
+
+
+
+```javascript JavaScript
+const result = await gladia.preRecorded().transcribe("audio.mp3", {
+ model: "solaria-3",
+ language_config: { languages: ["en"] },
+ diarization: true,
+});
+```
+
+```python Python
+result = gladia.transcribe(
+ "audio.mp3",
+ {
+ "model": "solaria-3",
+ "language_config": {"languages": ["en"]},
+ "diarization": True,
+ },
+)
+```
+
+
+
+## Live in a few lines
+
+Start a session, send audio, print finals as they arrive:
+
+
+
+```javascript JavaScript
+import { GladiaClient } from "@gladiaio/sdk";
+
+const gladia = new GladiaClient({ apiKey: "YOUR_GLADIA_API_KEY" });
+
+const session = gladia.liveV2().startSession({
+ encoding: "wav/pcm",
+ sample_rate: 16000,
+ bit_depth: 16,
+ channels: 1,
+});
+
+session.on("message", (message) => {
+ if (message.type === "transcript" && message.data.is_final) {
+ console.log(message.data.utterance.text);
+ }
+});
+
+// session.sendAudio(chunk)
+// session.stopRecording()
+```
+
+```python Python
+from gladiaio_sdk import GladiaClient, LiveV2InitRequest
+
+gladia = GladiaClient(api_key="YOUR_GLADIA_API_KEY")
+session = gladia.live_v2().start_session(
+ LiveV2InitRequest(
+ encoding="wav/pcm",
+ sample_rate=16000,
+ bit_depth=16,
+ channels=1,
+ )
+)
+
+@session.on("message")
+def on_message(message):
+ if getattr(message, "type", None) == "transcript":
+ data = message.data
+ if data.is_final:
+ print(data.utterance.text)
+
+# session.send_audio(chunk)
+# session.stop_recording()
+```
+
+
+
+## Full samples
+
+Clone ready-to-run examples for pre-recorded, live, and real use cases:
+
+
+ Python, TypeScript, and JavaScript samples on GitHub
+
+
+
+
+ Pre-recorded and live samples
+
+
+ Pre-recorded and live samples
+
+
+ Pre-recorded and live samples
+
+
+
+## Next guides
+
+
+
+ Jobs, webhooks, and audio intelligence
+
+
+ Streaming, partials, and session lifecycle
+
+
+ Choose Solaria-3 or Solaria-1
+
+
+ Transcribe from the terminal without app code
+
+
diff --git a/chapters/integrations/sdk.mdx b/chapters/integrations/sdk.mdx
deleted file mode 100644
index d1969a5..0000000
--- a/chapters/integrations/sdk.mdx
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: SDK
-description: "Use the SDK to integrate Gladia into your project"
-mode: "wide"
----
-
-To integrate Gladia into your project faster, and use all of our best practices for transcribing audio, you can use one of our SDKs.
-
-
- Want to start building realtime transcription applications with Gladia? Check out our [live transcription guide](/chapters/live-stt/quickstart).
-
-
-
-
- Use the JavaScript SDK to integrate Gladia into your project
-
-
- Use the Python SDK to integrate Gladia into your project
-
-
diff --git a/chapters/introduction/models.mdx b/chapters/introduction/models.mdx
index d5c7c64..a6dfcd7 100644
--- a/chapters/introduction/models.mdx
+++ b/chapters/introduction/models.mdx
@@ -113,7 +113,7 @@ Use Solaria-1 instead for live streaming, code switching, languages outside thos
Call Solaria-3 from JavaScript or Python.
@@ -153,7 +153,7 @@ Ideal default for voice agents, live captions, and global multilingual products.
Integrate with the official SDKs.
diff --git a/docs.json b/docs.json
index a13b564..2b3db53 100644
--- a/docs.json
+++ b/docs.json
@@ -12,7 +12,9 @@
"eyebrows": "breadcrumbs",
"codeblocks": "system"
},
- "fonts": { "family": "Inter" },
+ "fonts": {
+ "family": "Inter"
+ },
"appearance": {
"default": "system",
"strict": false
@@ -35,8 +37,11 @@
{
"group": "How to use Gladia",
"pages": [
+ "chapters/how-to-use-gladia/sdk",
"chapters/how-to-use-gladia/playground",
- "chapters/how-to-use-gladia/benchmarking"
+ "chapters/how-to-use-gladia/cli",
+ "chapters/how-to-use-gladia/benchmarking",
+ "chapters/how-to-use-gladia/gladia-flow"
]
},
{
@@ -64,7 +69,6 @@
}
]
},
-
{
"group": "Language",
"pages": [
@@ -94,7 +98,6 @@
{
"group": "Integrations",
"pages": [
- "chapters/integrations/sdk",
"chapters/integrations/pipecat",
"chapters/integrations/livekit",
"chapters/integrations/vapi",
@@ -141,7 +144,10 @@
"groups": [
{
"group": "API Documentation",
- "pages": ["api-reference/index", "api-reference/authentication"]
+ "pages": [
+ "api-reference/index",
+ "api-reference/authentication"
+ ]
},
{
"group": "Live endpoints",
@@ -320,6 +326,18 @@
"source": "/chapters/pre-recorded-stt/benchmarking",
"destination": "/chapters/how-to-use-gladia/benchmarking"
},
+ {
+ "source": "/chapters/integrations/sdk",
+ "destination": "/chapters/how-to-use-gladia/sdk"
+ },
+ {
+ "source": "/chapters/developer-tools/gladia-cli",
+ "destination": "/chapters/how-to-use-gladia/cli"
+ },
+ {
+ "source": "/chapters/introduction/benchmarking",
+ "destination": "/chapters/how-to-use-gladia/benchmarking"
+ },
{
"source": "/chapters/pre-recorded-stt/features/sentences",
"destination": "/chapters/audio-intelligence/sentences"
diff --git a/snippets/getting-started-playground.mdx b/snippets/getting-started-playground.mdx
index 6483a30..d034a63 100644
--- a/snippets/getting-started-playground.mdx
+++ b/snippets/getting-started-playground.mdx
@@ -1,11 +1,9 @@
[Gladia's playground](https://app.gladia.io/?utm_campaign=197609689-Website&utm_source=documentation&utm_content=sign-up
-) is a convenient way to test our Speech-To-Text API. On the playground
-you are able to transcribe remote audio files through URL, and also upload your local audio files, alongside with live
-audio transcription.
+) lets you try Speech-To-Text in the browser: mic stream, local upload, or remote URL. Compare models and features on your audio before you integrate.
- Choose your audio source (stream from you microphone, or upload a local file)
+ Choose your audio source (mic stream or local file upload).
@@ -15,13 +13,13 @@ audio transcription.
- You'll be able to select some of
- the options Gladia API provide for your transcription. \
- For this example, we want to detect the named entity (like email adresses, phone numbers, etc.), so we turned on **named entity recognition**.
+ Select some of
+ the options Gladia provides. \
+ In this example we enable **named entity recognition**.
- Only a few features of Gladia API are available on the playground. For more advanced testing,
- check [our API documentation](/api-reference/) instead.
+ Only a subset of API features is available in the playground. For advanced testing,
+ see the [API documentation](/api-reference/).
@@ -30,9 +28,9 @@ audio transcription.
- You can talk to Gladia by clicking on the "Start transcribing" button, and you'll be able to see the transcription of your voice in the "Transcription" tab.
+ Click **Start transcribing** to see your voice in the Transcription tab.
- Text in italic in the transcription represents [partials transcripts](/chapters/live-stt/features#partial-transcripts).
+ Italic text is [partial transcripts](/chapters/live-stt/features#partial-transcripts).
@@ -40,8 +38,7 @@ audio transcription.
- You can see an already formatted and readable results in the default "Transcription" tab, and you'll also find
- the result in JSON format (the one you'd get with an API call).
+ The Transcription tab shows a readable result. The JSON tab shows the same payload you would get from an API call.
diff --git a/snippets/integrations-cards.mdx b/snippets/integrations-cards.mdx
index e3973a4..0891023 100644
--- a/snippets/integrations-cards.mdx
+++ b/snippets/integrations-cards.mdx
@@ -4,7 +4,7 @@ If you want to build fast with Gladia, you can use one of our integration partne