> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://onepin.ai/docs/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://onepin.ai/docs/_mcp/server.

# Pronunciation Corrector

> The Onepin Pronunciation Corrector node (operator_pronunciation_corrector) — replaces only the words the Pronunciation validator flagged, keeping the surrounding audio and the voice unchanged.

**Family: Operator · `type: operator_pronunciation_corrector` · canvas name "Pronunciation Corrector" · beta**

The Pronunciation Corrector fixes mispronounced words *without regenerating the line*. For each word the [Pronunciation validator](/docs/workflow/pronunciation-validator) flagged, it re-synthesizes that word inside the existing take and splices it in — the surrounding audio, the delivery, and the voice all stay exactly as they were.

That's the difference between it and a plain retry loop. Sending a failing line back to the [Generator](/docs/workflow/generator) gets you a whole new read, which may fix the name and change everything else about the line. The Corrector changes only the word that was wrong.

> **Warning**
>
> **English only.** The Generator branch feeding a Corrector must produce `en-us` or `en-gb` audio. Unrelated branches of the same workflow may use other languages.

## Where it goes

**Only on a [Pronunciation validator](/docs/workflow/pronunciation-validator)'s `fail` or `pass` port.** Both are legitimate:

* On **`fail`** — the usual placement. It may send its corrected takes back to the *same* check to be re-graded, which forms a bounded retry loop: a `pass` ends it, and still-wrong words are corrected again within that check's retry budget.
* On **`pass`** — a passing line can still carry individual flagged words, because the check routes on the line's score independently of its per-word findings. A `pass` line with nothing flagged passes through untouched. A `pass`-fed Corrector must send its output **forward**; looping it back onto an earlier node makes the workflow unrunnable.

It must have at least one outgoing `lines` edge — either onward to a sink (the corrected take is delivered ungraded) or back to the same check to be re-graded.

```
   Pronunciation ──fail──▶ Pronunciation Corrector ──▶ back to Pronunciation (re-grade)
         │
        pass ──▶ Export
```

## Config

| Config key     | Default | Range                                                   |
| -------------- | ------- | ------------------------------------------------------- |
| `n_candidates` | `2`     | 1–8 (correction attempts drawn per word)                |
| `seed`         | none    | 0–2147483647 (pin sampling for reproducible candidates) |

```python
node["config"] = {"n_candidates": 2}
```

`n_candidates` is a ceiling, not a fixed cost: candidates are drawn one at a time and the first one that aligns well enough wins, so raising it only matters for words the model finds hard.

## What it costs

Billed **per word actually respliced** — not per character, and not per line. A line where one word out of forty was wrong costs one word, and a pass where every correction was skipped costs nothing, because your audio came back unchanged. Each retry iteration bills on its own, like every other node.

## Inspect this node

#### Python

```python
client.nodes.get_node_detail(node_type="operator_pronunciation_corrector").data
```

#### CLI

```bash
onepin nodes show operator_pronunciation_corrector
```

#### API

```bash
curl https://api.onepin.ai/api/v2/nodes/operator_pronunciation_corrector \
  -H "Authorization: Bearer $ONEPIN_API_KEY"
```

## Related

* [Pronunciation validator](/docs/workflow/pronunciation-validator) — decides what gets corrected
* [Phoneme Injector](/docs/workflow/phoneme-injector) — supplies the reference pronunciation
* [Fix pronunciations](/docs/guides/fix-pronunciations) — the whole chain, end to end