# Browser SDK - Developer Guide
Source: https://developer.sanas.ai/BrowserSDKDevGuide



The Sanas Browser SDK lets a web application send a live microphone stream through Sanas's audio processing (accent translation, speech enhancement, language translation) and receive the processed audio back as a `MediaStream`. It runs entirely in the browser and is transport-agnostic from your point of view: give it an input stream, receive an output stream.

This guide covers everything a developer needs to ship an integration. If you get stuck, jump to [Troubleshooting](#troubleshooting).

***

## Contents

1. [Overview](#overview)
2. [Installation](#installation)
3. [Authentication](#authentication)
4. [Quick start](#quick-start)
5. [Remote Inferencing mode (accent translation, speech enhancement)](#remote-inferencing-mode)
6. [Language Translation mode](#language-translation-mode)
7. [The processor lifecycle](#the-processor-lifecycle)
8. [API reference](#api-reference)
9. [Error handling](#error-handling)
10. [Advanced options](#advanced-options)
11. [Troubleshooting](#troubleshooting)

***

## Overview

The SDK exposes a single top-level object — `SanasSDK` — that manages a session. From that session you create one or more `AudioProcessor` instances, each of which:

* Takes a `MediaStream` in (typically from `navigator.mediaDevices.getUserMedia`).
* Emits a processed `MediaStream` out. You can attach the output to an `<audio>` element, feed it into WebRTC, or hand it to any other Web Audio API consumer.
* Runs one of two modes:
  * **Remote Inferencing (RI)** — a single Sanas model applied to the stream. Used for accent translation, speech enhancement, and other single-model features. You identify the model by name.
  * **Language Translation (LT)** — one-direction live translation. Each processor handles a single direction (say English → Spanish). A real two-person conversation uses **two processors** — one per speaker's direction — linked by a shared `conversationId` so the server can share context between them. Callbacks stream per-utterance transcripts and language-detection hints back.

Availability of RI and LT is controlled per group in the Sanas Developer Console. The SDK checks entitlement before creating a processor and throws a distinct error if a feature isn't enabled for your group.

## Installation

```text theme={null}
npm install @sanas-ai/browser-sdk
```

The package is self-contained — no peer dependencies. Works with any modern bundler (Vite, webpack, Next.js, Rollup, Parcel).

**Browser support:** Any browser that supports `MediaStream`, `RTCPeerConnection`, and `WebSocket` — Chrome 90+, Firefox 90+, Safari 15+, Edge 90+.

## Authentication

The SDK never sees your Sanas API key. Instead, it accepts a `tokenProvider` callback that asks *your* backend for a short-lived access token, and your backend uses its stored API key to mint one.

**Never embed a Sanas API key in browser code.** Anyone can view your bundle, extract the key, and use it against your usage budget.

### Backend responsibilities

Your backend needs a single endpoint (name it whatever you want) that:

1. Authenticates the browser request using your app's own session mechanism (cookies, JWT, etc. — that's your call).
2. Calls Sanas's OAuth token endpoint with your stored API key.
3. Returns the token payload to the browser as JSON.

Here's a minimal Node.js example (no dependencies beyond Node 18+):

```js theme={null}
import http from "node:http";

const SANAS_API_KEY = process.env.SANAS_API_KEY;
const SANAS_IDENTITY_URL = "https://identity.sanas.ai";
const ALLOWED_ORIGIN = process.env.ALLOWED_ORIGIN || "http://localhost:5173";

http.createServer(async (req, res) => {
  // CORS preflight
  if (req.method === "OPTIONS") {
    res.writeHead(204, corsHeaders());
    return res.end();
  }

  if (req.method === "POST" && req.url === "/token") {
    // Authenticate the calling browser session here (skipped for brevity).

    const upstream = await fetch(`${SANAS_IDENTITY_URL}/oauth2/api-key/login`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ apiKey: SANAS_API_KEY }),
    });

    const body = await upstream.text();
    res.writeHead(upstream.status, {
      "Content-Type": "application/json",
      ...corsHeaders(),
    });
    return res.end(body);
  }

  res.writeHead(404, corsHeaders());
  res.end();
}).listen(process.env.PORT || 4000);

function corsHeaders() {
  return {
    "Access-Control-Allow-Origin": ALLOWED_ORIGIN,
    "Access-Control-Allow-Methods": "POST, OPTIONS",
    "Access-Control-Allow-Headers": "Content-Type",
  };
}
```

Run it with `SANAS_API_KEY=... node server.js`.

### Browser side

```js theme={null}
import { SanasSDK, type TokenResponse } from "@sanas-ai/browser-sdk";

const sdk = new SanasSDK();

await sdk.initialize({
  tokenProvider: async (): Promise<TokenResponse> => {
    const res = await fetch("https://your-backend.example.com/token", {
      method: "POST",
      credentials: "include", // if you use cookie sessions
    });
    if (!res.ok) throw new Error(`Token request failed: ${res.status}`);
    return res.json();
  },
});
```

`tokenProvider` is called once at `initialize()` and again any time the SDK needs a fresh token. Make it idempotent and quick — the SDK will time it out after 30 seconds.

### Origin allowlisting

Every group in the Sanas Developer Console has an **allowed origins** list. All API calls the SDK makes from the browser include the page's origin; requests from a non-allowlisted origin are rejected. Add every origin your app runs on (production, staging, localhost during development) under **Project settings → Allowed origins**.

## Quick start

```js theme={null}
import { SanasSDK, ProcessorState } from "@sanas-ai/browser-sdk";

const sdk = new SanasSDK();

// 1. Initialize the SDK with your token provider.
await sdk.initialize({
  tokenProvider: () =>
    fetch("/token", { method: "POST" }).then((r) => r.json()),
});

// 2. Capture the microphone.
const input = await navigator.mediaDevices.getUserMedia({ audio: true });

// 3. Create a processor. RI mode with an accent-translation model:
const processor = await sdk.createAudioProcessor(
  { input, modelName: "AT5.2" },
  {
    // Drive your UI off state, not off the reason string.
    // `Initializing` — session is being set up; output is silent.
    // `Ready`        — audio is flowing through the processor.
    // `Failed`       — fatal error; the processor can't recover. Destroy it,
    //                  optionally show `reason` to the user, and create a new
    //                  one if you want to keep going.
    // `Disconnected` — you called destroyAudioProcessor(); terminal.
    onStateChange: (state, reason) => {
      if (state === ProcessorState.Ready) enableMicButton();
      if (state === ProcessorState.Failed) {
        disableMicButton();
        showBanner(reason);
      }
    },
  }
);

// 4. Attach the processed output to an <audio> element.
const audio = document.querySelector("audio")!;
audio.srcObject = processor.outputStream;
audio.play();

// 5. When you're done, tear down.
await sdk.destroyAudioProcessor(processor);
await sdk.shutdown();
```

## Remote Inferencing mode

For accent translation, speech enhancement, and similar single-model features. The model you use is provisioned in your Developer Console; the SDK verifies your group is entitled to the model before starting the call.

```js theme={null}
const processor = await sdk.createAudioProcessor(
  {
    input: micStream,
    modelName: "AT5.2", // as shown in the Developer Console
  },
  {
    onStateChange: (state, reason) => {
      if (state === ProcessorState.Ready) console.log("live");
      if (state === ProcessorState.Failed) console.error("failed:", reason);
    },
  }
);

audioElement.srcObject = processor.outputStream;
```

**Common errors:**

* `CreateProcessorErrorCode.FeatureNotEntitled` — Your group doesn't have Remote Inferencing enabled at all. Contact your Sanas administrator.
* `CreateProcessorErrorCode.ModelNotEntitled` — Your group has RI but not this specific model. Verify the exact name against the console.

## Language Translation mode

Each LT processor handles **one direction** of translation — one input language, one output language. A processor delivers translated audio out and streams two kinds of side-channel data via callbacks:

* `onTranscript` — a per-utterance transcript with partial and complete words for the detected input language.
* `onLanguageRoute` — a per-utterance language-detection result telling you which input language the server detected on that utterance (and which output language it will render).

### Two-person conversations use two processors

For a real conversation between two people who speak different languages, run **two processors on the same page**, one per direction, linked by a shared `conversationId`. For example, an English-speaking agent and a Spanish-speaking customer on the same call:

* Processor A: agent's mic (`languageIn: "en-US"`) → Spanish audio played to the customer (`languageOut: "es-ES"`).
* Processor B: customer's mic (`languageIn: "es-ES"`) → English audio played to the agent (`languageOut: "en-US"`).

Give both processors the same `conversationId` (any UUID you generate per call) and the server shares translation context between them — proper nouns, jargon, and prior context stay consistent across both directions.

```js theme={null}
const conversationId = crypto.randomUUID();

// Agent's mic → Spanish audio for the customer.
const outbound = await sdk.createAudioProcessor(
  {
    input: agentMicStream,
    languageIn: "en-US",
    languageOut: "es-ES",
    conversationId,
  },
  {
    onStateChange: (state, reason) => console.log("outbound", state, reason),
    onTranscript: (json) => console.log("outbound transcript", JSON.parse(json)),
    onLanguageRoute: (json) => console.log("outbound route", JSON.parse(json)),
  }
);
customerSpeakerElement.srcObject = outbound.outputStream;

// Customer's mic → English audio for the agent.
const inbound = await sdk.createAudioProcessor(
  {
    input: customerMicStream,
    languageIn: "es-ES",
    languageOut: "en-US",
    conversationId, // same UUID — shared context.
  },
  {
    onStateChange: (state, reason) => console.log("inbound", state, reason),
    onTranscript: (json) => console.log("inbound transcript", JSON.parse(json)),
    onLanguageRoute: (json) => console.log("inbound route", JSON.parse(json)),
  }
);
agentSpeakerElement.srcObject = inbound.outputStream;
```

`conversationId` is optional. Omit it if you're only running a single direction (e.g. a monologue translation) and don't need context sharing.

### Single-direction usage

If you only need to translate one direction (for example, translating a broadcast into another language), a single processor is enough:

```js theme={null}
const processor = await sdk.createAudioProcessor(
  {
    input: micStream,
    languageIn: "en-US",
    languageOut: "es-MX",
  },
  {
    onStateChange: (state, reason) => console.log(state, reason),
    onTranscript: (json) => console.log("transcript", JSON.parse(json)),
    onLanguageRoute: (json) => console.log("route", JSON.parse(json)),
  }
);
```

### `onTranscript` payload

Delivered as a JSON string; parse before use. **Fires multiple times per utterance** as the server refines its hypothesis. Each event carries a mix of `complete` (newly-finalized words) and `partial` (still-in-flight words).

```json theme={null}
{
  "type": "transcription",
  "transcription": {
    "lang": "en-US",
    "utterance_idx": 0,
    "complete": [],
    "partial": [
      { "word": "Hi",      "start": 0.0, "end": 0.0, "probability": 0.900 },
      { "word": ",",       "start": 0.0, "end": 0.0, "probability": 0.881 },
      { "word": " testing","start": 0.0, "end": 0.0, "probability": 0.941 },
      { "word": " of",     "start": 0.0, "end": 0.0, "probability": 0.936 }
    ]
  }
}
```

**How the stream evolves for one utterance.** `partial` is the current best guess and is replaced wholesale each event as the server refines it. `complete` is a **delta of newly-finalized words in this event only** — it is *not* the running total of everything finalized so far. To get the full utterance you must accumulate `complete` per `utterance_idx` on your side. `end` / `start` timestamps are reserved for future use and can be treated as 0.

For example, an utterance like "Hi, testing of language translation." arrives across several events. The `complete` deltas are `[]`, `[]`, `["Hi", ",", " testing", " of"]`, `[" language"]`, `[" translation"]`, `["."]` — concatenating those deltas rebuilds the full sentence.

Minimal accumulator:

```js theme={null}
const utterances = new Map<number, string>();

onTranscript: (json) => {
  const { transcription } = JSON.parse(json);
  const prev = utterances.get(transcription.utterance_idx) ?? "";
  const finalized = transcription.complete.map((w) => w.word).join("");
  const pending = transcription.partial.map((w) => w.word).join("");
  utterances.set(transcription.utterance_idx, prev + finalized);
  render(prev + finalized + pending); // finalized + current guess
};
```

Trailing punctuation typically arrives in its own event a second after the last word — plan your UI to accept it gracefully rather than assuming the utterance is done as soon as `partial` empties.

`utterance_idx` starts at 0 and increments per utterance. It correlates with `onLanguageRoute` events so you can label transcripts with the language the server detected.

### `onLanguageRoute` payload

Fires **once at the start of each utterance**, before the transcript events for that utterance begin arriving. Tells you the input language the server detected on that utterance and the output language it's rendering into.

```json theme={null}
{
  "type": "language_route_chosen",
  "language_route_chosen": {
    "utterance_idx": 1,
    "lang_in": "en-US",
    "lang_out": "es-ES",
    "is_final": true
  }
}
```

* `utterance_idx` — correlates with `onTranscript` events for the same utterance.
* `lang_in` / `lang_out` — the concrete input and output languages for this utterance.
* `is_final` — `true` when the server has locked in the routing for this utterance. In wildcard-mode edge cases the server may emit tentative routes with `is_final: false` before it commits; a subsequent event with the same `utterance_idx` and `is_final: true` supersedes the earlier one.

Fires for every utterance in both normal and wildcard mode. In **wildcard mode**, set `languageIn` or `languageOut` to `"*"` when creating the processor and the server detects the actual language for you; the value you get here is the concrete language the server chose. In **normal mode** (fixed `languageIn` / `languageOut`), the values echo back what the server confirmed for that utterance.

### Changing languages mid-call

Rather than tearing down and recreating the processor (which drops the call), swap languages in place:

```text theme={null}
await processor.updateLanguageConfig({
  languageIn: "en-US",
  languageOut: "fr-FR",
});
```

Usage attribution correctly rotates across language changes — the SDK bills each language segment separately without losing history when you switch back.

**Common error:**

* `CreateProcessorErrorCode.FeatureNotEntitled` — Language Translation isn't enabled for your group. Contact your Sanas administrator.

## The processor lifecycle

Every processor moves through a small state machine, observable via `onStateChange`:

```text theme={null}
Initializing ──► Ready ──► Disconnected (consumer destroyed)
    │              │
    │              └──► Failed (mid-call error)
    │
    └──► Failed (setup error)
```

* **Initializing** — the SDK is negotiating the media session. `outputStream` exists and is silent.
* **Ready** — the media session is up. `outputStream` is now delivering processed audio.
* **Failed** — a fatal error occurred. Read `reason` for a short human-readable explanation. The processor cannot be recovered; destroy it and create a new one.
* **Disconnected** — the consumer called `destroyAudioProcessor`. Terminal, expected.

The `outputStream` reference is **stable for the life of the processor** — you can attach it to an `<audio>` element or WebRTC track before the processor reaches `Ready`, and it will start emitting audio automatically once the media path opens.

## API reference

### `SanasSDK`

```ruby theme={null}
class SanasSDK {
  initialize(params: InitParams): Promise<void>;
  isInitialized(): boolean;
  createAudioProcessor(
    params: AudioProcessorParams,
    callbacks?: ProcessorCallbacks
  ): Promise<IAudioProcessor>;
  destroyAudioProcessor(processor: IAudioProcessor): Promise<void>;
  getActiveProcessorCount(): number;
  shutdown(): Promise<void>;
}
```

#### `initialize(params)`

Establish a session with your token provider and validate your group's entitlements. Must be called before `createAudioProcessor`. Calling `initialize` twice throws `InitErrorCode.AlreadyInitialized`.

#### `createAudioProcessor(params, callbacks?)`

Create a processor for a single audio stream. You can hold multiple active processors on one SDK instance (each processes an independent stream).

Wire callbacks at construction — they are guaranteed to fire even for the initial `Initializing → Failed` transition on setup errors.

#### `destroyAudioProcessor(processor)`

Gracefully tear down a single processor. The output stream ends. Emits a final usage snapshot before returning so that usage accounting is complete.

#### `shutdown()`

Destroy all live processors, stop background reporting, clear all session state. Call this on page unload or when your app no longer needs Sanas. After `shutdown`, you can call `initialize` again to start a new session.

### `InitParams`

```typescript theme={null}
interface InitParams {
  tokenProvider: () => Promise<TokenResponse>;
  logLevel?: "debug" | "info" | "warn" | "error" | "silent";
  jitterBufferTargetMs?: number;
}
```

### `TokenResponse`

```typescript theme={null}
interface TokenResponse {
  access_token: string;
  user_id: string;
  group_id: string;
  expires_in?: number;
  authenticated_at?: string;
  token_type?: string;
}
```

This is exactly the shape returned by Sanas's OAuth login endpoint — your backend can forward the response body verbatim.

### `AudioProcessorParams`

A discriminated union:

```typescript theme={null}
type AudioProcessorParams =
  | AudioProcessorModelParams
  | AudioProcessorLanguageParams;

interface AudioProcessorModelParams {
  input: MediaStream;
  modelName: string;
  sampleRate?: number;
  jitterBufferTargetMs?: number;
}

interface AudioProcessorLanguageParams {
  input: MediaStream;
  languageIn: string;
  languageOut: string;
  conversationId?: string;
  sampleRate?: number;
  jitterBufferTargetMs?: number;
}
```

### `ProcessorCallbacks`

```typescript theme={null}
interface ProcessorCallbacks {
  onStateChange?: (state: ProcessorState, reason: string) => void;
  onTranscript?: (json: string) => void;
  onLanguageRoute?: (json: string) => void;
}
```

The two JSON callbacks fire only for LT processors. The payload is a raw JSON string — parse with `JSON.parse` on your side.

### `IAudioProcessor`

```typescript theme={null}
interface IAudioProcessor {
  readonly outputStream: MediaStream;
  getState(): ProcessorState;
  updateInputStream(input: MediaStream): Promise<void>;
  updateLanguageConfig(config: {
    languageIn: string;
    languageOut: string;
    conversationId?: string;
  }): Promise<void>;
}
```

`updateInputStream` swaps the mic mid-call (device change, headset unplug) without dropping the session.

`updateLanguageConfig` throws if called on a model-mode processor.

### `ProcessorState`

```text theme={null}
enum ProcessorState {
  Initializing = "initializing",
  Ready = "ready",
  Failed = "failed",
  Disconnected = "disconnected",
  Unknown = "unknown",
}
```

## Error handling

All SDK errors are instances of `SdkError` with a machine-readable `code` and a human-readable `message`.

```js theme={null}
import { SdkError, InitErrorCode } from "@sanas-ai/browser-sdk";

try {
  await sdk.initialize({ tokenProvider });
} catch (err) {
  if (err instanceof SdkError && err.code === InitErrorCode.OriginNotAllowed) {
    showBanner("This origin isn't allowed. Contact your admin.");
  } else {
    throw err;
  }
}
```

### `InitErrorCode`

| Code | Meaning | Recommended action |
| - | - | - |
| `AlreadyInitialized` | `initialize` was called on an already-initialized SDK. | Call `shutdown()` first, or reuse the existing session. |
| `InitializationInProgress` | A concurrent `initialize` is still running. | Await the first call before starting another. |
| `InvalidParameters` | `tokenProvider` was missing or not a function. | Check the call site. |
| `AuthenticationFailed` | Your backend returned an error, or the token payload was malformed. | Log the message; verify your backend is returning `{access_token, user_id, group_id, ...}`. |
| `OriginNotAllowed` | This page's origin isn't in the group's allowed list. | Add the origin in **Project settings → Allowed origins**. |
| `NetworkError` | Network / CORS failure reaching either your backend or the Sanas console. | Message includes which stage failed; check CORS on your backend or inspect DevTools network tab for the console request. |
| `UnknownError` | Anything else. | Read the message; open a support ticket if it recurs. |

### `CreateProcessorErrorCode`

| Code | Meaning | Recommended action |
| - | - | - |
| `SdkNotInitialized` | You didn't call `initialize`, or the session was lost. | Initialize (or reinitialize) before creating processors. |
| `InvalidParameters` | Required field missing or unsafe characters in a param. | Check `modelName` / `languageIn` / `languageOut` values. |
| `UnsupportedSampleRate` | The requested sample rate isn't supported. | Use 8000, 16000, or 48000. |
| `ModelNotEntitled` | The model name isn't in this group's entitlements. | Verify the exact name in the console. Case-sensitive. |
| `FeatureNotEntitled` | The feature (RI or LT) isn't enabled at group level. | Contact your Sanas administrator. |
| `OriginNotAllowed` | Same as init — origin got revoked between init and this call. | Update **Project settings → Allowed origins**. |
| `NetworkError` | Console API unreachable for the entitlement check. | Retry; check DevTools. |
| `UnknownError` | Anything else. | Read the message. |

### Runtime state changes

Once a processor is created, transient failures surface through `onStateChange(Failed, reason)`, not by throwing. Wire the callback at construction so you never miss an early failure:

```js theme={null}
sdk.createAudioProcessor(params, {
  onStateChange: (state, reason) => {
    if (state === ProcessorState.Failed) {
      // reason is a short user-facing string
      // e.g. "Server rejected the call (auth failure)"
      // e.g. "Media connection lost"
      // e.g. "Authentication lost: origin not allowed for this group"
      // e.g. "Entitlement revoked: language_translation is no longer available for this group"
      showErrorBanner(reason);
    }
  },
});
```

## Advanced options

### Sample rate

Default is 16000 Hz. Supported: 8000 / 16000 / 48000. Set per processor:

```text theme={null}
sdk.createAudioProcessor({ input, modelName: "...", sampleRate: 48000 }, ...);
```

Rates outside the supported set throw `UnsupportedSampleRate`.

### Jitter buffer

For bumpy networks, increase the receive-side buffer to smooth playback at the cost of extra latency. Default is chosen by the SDK; override globally in `InitParams` or per processor:

```text theme={null}
await sdk.initialize({ tokenProvider, jitterBufferTargetMs: 200 });
// or
sdk.createAudioProcessor(
  { input, modelName: "...", jitterBufferTargetMs: 100 },
  ...
);
```

### Swapping input mid-call

Users unplug headsets or switch devices. Update in place instead of tearing down:

```js theme={null}
const newInput = await navigator.mediaDevices.getUserMedia({
  audio: { deviceId: newDeviceId },
});
await processor.updateInputStream(newInput);
```

The active call stays up; the outgoing track is swapped.

### Multiple concurrent processors

You can run more than one processor per SDK instance — e.g. a mic in RI mode and a system-audio stream in LT mode. Each is fully independent.

### Logging

Set `logLevel: "debug"` in `InitParams` to see the SDK's internal logs in DevTools. Default is `warn`. Use `silent` in production if you want no console output.

## Troubleshooting

\*\*"Origin not allowed" during \*\*`initialize`<br />Your page's origin (protocol + host + port) isn't in the group's allowed list. Add it under **Project settings → Allowed origins**. Note that `http://localhost:5173` and `http://localhost:3000` are different origins — add every dev port you use.

**Processor reaches `Failed` immediately with "Server rejected the call (auth failure)"**<br />The access token expired between `tokenProvider` returning it and the media session opening, or your backend returned a stale token.

**Processor reaches `Failed` mid-call with "Media connection lost"**<br />Network dropped. The SDK does not auto-reconnect a lost media session. Destroy the processor and create a new one.

**Metrics appear delayed**<br />The SDK batches usage reports on a 1-minute cadence. If you tear down a processor, the final snapshot is captured before the underlying session closes.


# Sanas Cloud
Source: https://developer.sanas.ai/Docs/Deployment/Sanas-Cloud

Cloud-hosted deployment for the Sanas SDK

Sanas manages all infrastructure so you can focus on building. Recommended for most use cases.

<CardGroup>
  <Card title="Fully Managed" icon="server">
    Enterprise-grade cloud infrastructure. No servers to maintain.
  </Card>

  <Card title="Auto Scaling" icon="arrows-maximize">
    Scales automatically with your traffic. High availability built in.
  </Card>

  <Card title="Secure" icon="lock">
    Encrypted media transmission with secure authentication.
  </Card>
</CardGroup>

## Available Regions

| Region | Location | AWS Region |
| - | - | - |
| **South Asia** | Mumbai, India | `ap-south-1` |
| **United States** | Ohio, USA | `us-east-2` |

<Info>
  More regions coming soon.
</Info>

## Best For

<CardGroup>
  <Card title="Fast Time to Market" icon="bolt">
    Start processing audio in minutes, not weeks.
  </Card>

  <Card title="Real-Time Voice" icon="phone">
    Low-latency streaming for voice agents and live calls.
  </Card>

  <Card title="Scale" icon="layer-group">
    Handle hundreds of concurrent streams with consistent performance.
  </Card>
</CardGroup>

## Pricing

Usage-based — pay for what you process. [View pricing details →](/Docs/Resources/Pricing)

<Card title="Ready to build?" icon="rocket" href="/Docs/Getting-Started/Quick-Start">
  Jump to the Quick Start and process your first audio stream.
</Card>


# Self-Hosted (Coming Soon)
Source: https://developer.sanas.ai/Docs/Deployment/Self-Hosted

Self-hosted deployment for the Sanas SDK

<Note>Self-hosted deployment coming soon. [Contact us](https://support.sanas.ai/support/home) for early access.</Note>

Host Sanas AI models on your own infrastructure for full control over data and deployment.

<CardGroup>
  <Card icon="shield" title="Full Control">
    Your servers, your data. Complete control over the deployment.
  </Card>

  <Card icon="building" title="On-Premise">
    Deploy in your own data center or private cloud.
  </Card>

  <Card icon="lock" title="Compliance Ready">
    Meet HIPAA, GDPR, and data residency requirements.
  </Card>
</CardGroup>

## Requirements

| Component | Requirement |
| - | - |
| **Operating System** | Ubuntu 22.04 (recommended) |
| **Network** | SIP/RTP-capable configuration |
| **Resources** | Planned for real-time processing workloads |
| **Maintenance** | Monitoring and updates managed by your team |

## Best For

<CardGroup>
  <Card icon="scale-balanced" title="Regulatory Compliance">
    HIPAA, GDPR, and industry-specific compliance requirements.
  </Card>

  <Card icon="globe" title="Data Residency">
    Keep audio data within specific geographic boundaries.
  </Card>

  <Card icon="building" title="On-Premise Deployments">
    Run entirely within your own infrastructure.
  </Card>

  <Card icon="wifi-slash" title="Air-Gapped Environments">
    No external network connectivity required.
  </Card>
</CardGroup>

## Pricing

Self-hosted pricing is based on your deployment scale and requirements. [Contact sales](https://support.sanas.ai/support/home) for details.

<Card title="Contact support for self-hosting" icon="headset" href="https://support.sanas.ai/support/home">
  Talk to our team about self-hosted deployment options and requirements.
</Card>


# Compliance & Data Residency
Source: https://developer.sanas.ai/Docs/Enterprise/Compliance-and-Data-Residency



Sanas maintains enterprise-grade compliance standards and gives you full control over where your data is processed and stored.

## Certifications

<CardGroup>
  <Card icon="certificate" title="ISO 27001:2022">
    Information security management system certified.
  </Card>

  <Card icon="shield" title="SOC 2 Type II">
    SSAE-21 SOC 2 Type 2 attested.
  </Card>

  <Card icon="lock" title="HIPAA">
    Compliant. BAA available for enterprise customers.
  </Card>

  <Card icon="globe" title="GDPR">
    Compliant with EU, UK, and Swiss data protection regulations.
  </Card>

  <Card icon="credit-card" title="PCI DSS">
    Payment card industry data security standard compliant.
  </Card>

  <Card icon="flag" title="CCPA">
    California Consumer Privacy Act compliant.
  </Card>
</CardGroup>

## Data Handling

<CardGroup>
  <Card icon="bolt" title="Real-Time Processing">
    Audio is processed in real-time and not stored on Sanas Cloud.
  </Card>

  <Card icon="trash" title="No Data Retention">
    User call audio is never sent to Sanas servers for storage.
  </Card>

  <Card icon="server" title="Self-Hosted Option">
    Self-hosted deployments keep all data within your infrastructure.
  </Card>
</CardGroup>

For technical security details (encryption, access control, infrastructure), see [Security](/Docs/Enterprise/Security).

## Data Residency

| Deployment | Data Location | Audio Leaves Your Infra? |
| - | - | - |
| Sanas Cloud — US East | AWS `us-east-2` (Ohio, USA) | Yes |
| Sanas Cloud — South Asia | AWS `ap-south-1` (Mumbai, India) | Yes |
| Self-Hosted | Your own servers | Never |

<Info>More regions coming soon.</Info>

## Sub-Processors

| Sub-Processor | Purpose | Location |
| - | - | - |
| **Amazon Web Services** | Hosting production environment | US |
| **Microsoft Azure** | CDN provider | US |
| **ClickHouse** | Hosting telemetry database | US |

Customers receive 30 days' notice before new sub-processors are authorized.

## Data Retention

* During agreement: data retained per contract terms
* Post-termination: 30 days to request deletion or return
* Automatic deletion within 6 months after termination
* Backup data deleted within 1 year post-termination

## Your Rights

You can request access, correction, deletion, restriction, or portability of your personal data at any time.

**Contact:** [privacy@sanas.ai](mailto:privacy@sanas.ai)

## Learn More

<CardGroup>
  <Card title="Trust Vault" icon="shield" href="https://trust.sanas.ai/">
    Full security posture and compliance documentation.
  </Card>

  <Card title="Data Processing Agreement" icon="file-contract" href="https://www.sanas.ai/data-processing-agreement">
    Complete data processing terms and commitments.
  </Card>

  <Card title="Privacy Policy" icon="user-shield" href="https://www.sanas.ai/privacy-policy">
    How Sanas collects, uses, and protects your information.
  </Card>

  <Card title="Data Security FAQ" icon="circle-question" href="https://help.sanas.ai/docs/faqs-data-security-and-privacy">
    Frequently asked questions about data security and privacy.
  </Card>
</CardGroup>


# Security
Source: https://developer.sanas.ai/Docs/Enterprise/Security



Sanas is built with enterprise-grade security at every layer — from authentication to audio transmission.

## Network Security

All communication between the SDK Connector and Sanas Cloud uses SIP for connection establishment and RTP for audio streaming. See [Sanas Cloud deployment](/Docs/Deployment/Sanas-Cloud) for firewall and network configuration details.

## Encrypted Audio Transmission

All audio is always encrypted in transit between the SDK Connector and Sanas Cloud. Secure media is enabled by default and is not configurable.

## Encryption & Access Control

<CardGroup>
  <Card title="Encryption" icon="lock">
    AES-256 encryption at rest. TLS encryption in transit.
  </Card>

  <Card title="Access Control" icon="user-lock">
    Role-based access control using least-privilege principles.
  </Card>

  <Card title="Infrastructure" icon="server">
    Hosted on AWS with ISO 27001 certified data centers. Daily backups across multiple availability zones.
  </Card>

  <Card title="Monitoring" icon="eye">
    24/7 automated infrastructure monitoring.
  </Card>
</CardGroup>

For certifications, data residency, sub-processors, and retention policies, see [Compliance & Data Residency](/Docs/Enterprise/Compliance-and-Data-Residency).

***

## Need Help?

<CardGroup>
  <Card title="Email Support" icon="envelope" href="mailto:support@sanas.ai">
    [support@sanas.ai](mailto:support@sanas.ai)

    Response time: 1 business day
  </Card>

  <Card title="Support Portal" icon="ticket" href="https://support.sanas.ai">
    Raise a support ticket for urgent issues
  </Card>
</CardGroup>


# Support
Source: https://developer.sanas.ai/Docs/Enterprise/Support



Need help? Reach out to our team.

<CardGroup>
  <Card title="Email Support" icon="envelope" href="mailto:support@sanas.ai">
    [support@sanas.ai](mailto:support@sanas.ai)

    Response time: 1 business day
  </Card>

  <Card title="Support Portal" icon="ticket" href="https://support.sanas.ai/support/home">
    Raise a support ticket for urgent issues and priority queue access.
  </Card>
</CardGroup>


# Set up account
Source: https://developer.sanas.ai/Docs/Getting-Started/Authentication

Create a developer account.

## Overview

Create a developer account get your API keys for Sanas Cloud. Download the SDK libraries and start building.

## Create a Developer Account

<Steps>
  <Step title="Sign up for a developer account. ">
    Please visit  [**console.sanas.ai**](https://console.sanas.ai).
  </Step>

  <Step title="Create a project in the Developer Console">
    Log in to the Developer Console and create a new project. Projects let you organize API keys and usage by application or environment.
  </Step>

  <Step title="Create an API Key">
    Inside your project, generate an API Key from the Developer Console. You'll use this key to activate the SDK, as shown in the code example below. Treat it like a secret: load it from an environment variable rather than hardcoding it.
  </Step>
</Steps>

## Code Example

Here's how to use your credentials to initialize the SDK:

```python theme={null}
import sanas
import os

# Create SDK instance (storage_dir is where the SDK keeps data and logs)
sdk = sanas.create_sdk(sanas.InitParams(storage_dir="./storage"))

# Activate your account with your API key (use environment variables in production)
api_key = os.getenv("SANAS_API_KEY", "your_api_key")
result = sdk.activate_api_key(api_key)

if not result.success:
raise RuntimeError(f"activation failed ({result.error_type}): {result.message}")

print("SDK initialized and activated successfully")
```

***

## Next Steps

<CardGroup>
  <Card title="Quick Start" icon="rocket" href="/Docs/Getting-Started/Quick-Start">
    [Install the SDK](/Docs/Getting-Started/Quick-Start) and process your first audio stream.
  </Card>

  <Card title="Deployment Options" icon="cloud" href="/Docs/Deployment/Sanas-Cloud">
    Learn about Sanas Cloud and self-hosted deployments.
  </Card>
</CardGroup>

***

## Need Help?

<CardGroup>
  <Card title="Email Support" icon="envelope" href="mailto:support@sanas.ai">
    [support@sanas.ai](mailto:support@sanas.ai)

    Response time: 1 business day
  </Card>

  <Card title="Support Portal" icon="ticket" href="https://support.sanas.ai">
    Raise a [support ticket](https://help.sanas.ai/) for urgent issues
  </Card>
</CardGroup>


# Overview of Sanas
Source: https://developer.sanas.ai/Docs/Getting-Started/Overview

Get started building with real-time speech AI using the Sanas SDK

## What is Sanas SDK?

The Sanas SDK processes speech audio in real time. You feed it audio frames and it returns processed audio frames — for example noise-cancelled, speech-enhanced, or accent-converted speech, or speech translated into another language.

With **audio processing** (things like noise cancellation, speech enhancement, and accent conversion), you pick the specific model you want and the system cleans up or transforms the audio almost instantly.<br />**Language Translation** works a little differently. Instead of choosing a model, you just tell it the language someone is speaking and the language you want them heard in. Behind the scenes it does three jobs — transcribes the speech, translates it, and re-speaks it in the target language — and hands you back both the translated audio and a text transcript. Because it's doing all three steps, it takes a few seconds longer than the audio-processing features, so it's best suited to conversations where a slight delay is fine.

> **The good news: setting it up is the same either way. The connection, activation, and start-up steps are identical — Language Translation just needs the language settings instead of a model choice.**

The Python package ships as a **self-contained wheel**: everything the SDK needs is bundled inside it, so there is no separate native library to install or manage. You just create a virtual environment and `pip install` the wheel. You work with **interleaved float32 PCM** audio: push frames in with `process_frame` and read processed frames back. The SDK does not open microphones or speakers for you — you bring your own audio (from a file, a socket, a media stream, etc.). Enterprise-ready with [security](/Docs/Enterprise/Security), [compliance](/Docs/Enterprise/Compliance-and-Data-Residency), and [support](/Docs/Enterprise/Support).

Sanas also offers a standalone [Language Translation API](/Docs/Language-Translation/Overview) for real-time speech-to-speech in the browser — if that's your use case, start there instead of the SDK.

## What can you do with the Sanas SDK ?

* **Audio processing** — run a model (speech enhancement, accent conversion,…) over your audio, selected by a model key.
* **Language Translation (LT)** — translate speech from one language to another and receive both translated audio and transcript segments.
* **Pipeline lifecycle** — an `audio_pipeline_state_notify` callback reports the processing pipeline state (`PipelineState`); wait for `RUNNING` before feeding frames.

**Audio processing vs. Language Translation.** The SDK supports two modes that differ in how you select them and what they return. **Audio processing** (speech enhancement, noise cancellation, accent conversion) is chosen by setting a **model key** on `AudioAttributes.model_name` — for example `SE2.2` or `AT5.2` — and returns processed audio frames with minimal latency.

**Language Translation (LT)** is selected instead by supplying a `LanguageTranslationConfig` (`lt_config`) and leaving `model_name` empty; you specify a source and target language rather than a model, and the pipeline returns both translated audio *and* transcript segments via a callback. Because LT runs speech-to-text, translation, and text-to-speech end to end, it carries higher latency than the audio-processing models, so plan for a longer buffer/drain window. Everything else stays the same: you use the identical `create_sdk` → `activate_api_key` → `create_audio_processor` flow and wait for `PipelineState.RUNNING` before feeding frames.

<Note>
  This describes Language Translation **inside the Python SDK** (`lt_config`). For real-time speech-to-speech in the browser, Sanas also offers a standalone [Language Translation API](/Docs/Language-Translation/Overview) — WebRTC / WebSocket / JavaScript client with an `init`/`configure` protocol. Use that instead of the SDK if you're building a web app.
</Note>

Key types: `InitParams`, `create_sdk`, `Sdk`, `AudioAttributes`, `ProcessorAttributes`, `AudioProcessor`, `AudioFrame`, `LanguageTranslationConfig`, `CloudInferencingParams`, `PipelineState`, `SdkResult`.

### How Audio processing works.

The Sanas SDK Connector sits between your application and Sanas Models, managing the connection to the inference engine. It sends input, receives processed output, and streams data in real-time using SIP (Session Initiation Protocol) and RTP (Real-Time Transport Protocol). The Sanas SDK can be deployed via [Sanas Cloud](/Docs/Deployment/Sanas-Cloud) (recommended) or [self-hosted](/Docs/Deployment/Self-Hosted) *(coming soon)* on your own infrastructure.

```mermaid theme={null}
graph LR
    A[Input] --> B[SDK Connector] --> C[Sanas Models] --> D[Output]
    style A fill:#F7F7F7,stroke:#E3E3E3,color:#242424
    style B fill:#44ECA0,stroke:#44ECA0,color:#000
    style C fill:#242424,stroke:#242424,color:#fff
    style D fill:#44ECA0,stroke:#44ECA0,color:#000
```

## Core Capabilities

<CardGroup>
  <Card title="Speech Enhancement " icon="volume-slash" href="/speech-enhancement-overview">
    Isolate intended speech by removing background noise and voices — no quality degradation.
  </Card>

  <Card title="Speech Enhancement for Agentic Noise Cancellation" icon="robot" href="/Docs/Models/Human-Machine/Agentic-SE-Voice-Isolation">
    Clean audio before ASR/STT. Isolate primary speakers and reduce Relative Word Error Rate (RWERR).
  </Card>

  <Card title="Speech Enhancement with full-fidelity" icon="waveform-lines" href="/Docs/Models/Human-Human/SE-full-fidelity">
    Reconstruct and restore speech quality degraded by compression and network conditions.
  </Card>

  <Card title="Live Language Translation" icon="globe" href="/Docs/Language-Translation/Overview">
    Real-time cross-language voice communication.
  </Card>

  <Card title="Accent Translation" icon="language" href="/Docs/Models/Human-Human/Accent-Translation/Accent-Translation">
    Convert accents while preserving voice identity.
  </Card>
</CardGroup>

<Note>
  Sanas currently offers Speech Enhancement (audio clarification), Accent Translation, and Language Translation. Speech Intelligence coming soon.
</Note>

## Available Models

<CardGroup>
  <Card title="SE Voice Isolation (General)" icon="volume-slash" href="/Docs/Models/Human-Human/SE-Voice-Isolation">
    **`VI_G_SE`** Isolates intended speech by removing background noise and voices. Optimized for human listeners.
  </Card>

  <Card title="Speech Enhancement · Standard" icon="microphone" href="/Docs/Models/Human-Human/SE-Standard">
    **`SE2.1`** Restores and enhances voice quality for telephony audio. Low CPU footprint.
  </Card>

  <Card title="Speech Enhancement · Full-Fidelity" icon="microphone" href="/Docs/Models/Human-Human/SE-full-fidelity">
    **`SE2.2`** Full-fidelity speech enhancement with bandwidth extension to ultra-fidelity 24kHz.
  </Card>

  <Card title="Agentic Speech Enhancement· Voice Isolation (General)" icon="robot" href="/Docs/Models/Human-Machine/Agentic-SE-Voice-Isolation">
    **`AGENTIC_VI_G_SE`** Removes background noise and distant voices for complete voice isolation of the primary speaker's audio stream.
  </Card>

  <Card title="Agentic Noise Clarification · Voice Isolation (Telephony)" icon="robot" href="/Docs/Models/Human-Machine/Agentic-Speech-Enhancement/Agentic-SE-Voice-Isolation-Telephony">
    **`AGENTIC_VI_GT_SE`** Telephony-optimized variant of Voice Isolation for 8kHz narrowband audio.
  </Card>

  <Card title="Agentic Speech Enhancement · Standard" icon="robot" href="/Docs/Models/Human-Machine/Agentic-Speech-Enhancement/Agentic-SE-Standard">
    **`AGENTIC_ST_SE`** Removes background noise while preserving all human speech for multi-speaker environments.
  </Card>

  <Card title="Accent Translation" icon="robot" href="/Docs/Models/Human-Human/Accent-Translation/Accent-Translation">
    **`AT5.2`** Accent Translation modifies global accents in real-time, allowing your teams to be instantly understood while preserving what makes every voice unique.
  </Card>

  <Card title="Language Translation" icon="robot" href="/Docs/Language-Translation/Overview">
    [See LT Documentation](/Docs/Language-Translation/Overview) Real-time language translation that preserves your speakers' voices, tone, and intent.
  </Card>
</CardGroup>

See the [full model comparison →](/Docs/Models/Overview)

## What You Can Build

<CardGroup>
  <Card title="Voice Agents" icon="robot">
    Enhance voice agent pipelines with real-time speech and audio processing for clearer, more accurate interactions.
  </Card>

  <Card title="Contact Centers" icon="headset">
    Power contact center audio at scale with concurrent stream processing and enterprise-grade reliability.
  </Card>

  <Card title="Conferencing & Gaming" icon="users">
    Deliver high-quality voice experiences across communication and interactive platforms.
  </Card>

  <Card title="STT Pipelines" icon="microchip">
    Improve speech-to-text accuracy by processing audio before it reaches your transcription engine.
  </Card>
</CardGroup>

## Key Features

<CardGroup>
  <Card title="Real-Time Streaming" icon="bolt">
    **Low-latency processing** Live audio processing with SIP/RTP
  </Card>

  <Card title="High Concurrency" icon="layer-group">
    **Scalable solution** Process multiple audio streams simultaneously
  </Card>

  <Card title="Session Management" icon="link">
    **SIP protocol** Reliable connection establishment and management
  </Card>

  <Card title="Seamless Communication" icon="puzzle-piece">
    Enable clearer human-machine interactions across any environment
  </Card>

  <Card title="Easy Integration" icon="code">
    **Simple API** Initialize, create a processor, stream audio
  </Card>

  <Card title="Secure" icon="lock">
    **Enterprise security** Encrypted transmission, secure authentication
  </Card>
</CardGroup>

## Ready to Build?

Request your API keys and integration credentials, then use the Quick Start to start streaming clean audio in minutes.

<CardGroup>
  <Card title="Sign up for account here " icon="key" href="https://www.sanas.ai/developer-platform">
    Get your [developer account](https://www.sanas.ai/developer-platform) to start building.
  </Card>

  <Card title="Quick Start" icon="rocket" href="/Docs/Getting-Started/Quick-Start">
    [Get up and running with Sanas SDK in under 5 minutes.](/Docs/Getting-Started/Quick-Start)
  </Card>
</CardGroup>

## Resources

<CardGroup>
  <Card title="Pricing" icon="dollar-sign" href="/Docs/Resources/Pricing">
    [Usage-based pricing.](/Docs/Resources/Pricing)
  </Card>

  <Card title="Enterprise" icon="building" href="/Docs/Enterprise/Compliance-and-Data-Residency">
    Data residency, compliance, security, and support.
  </Card>

  <Card title="API Reference" icon="book" href="/API-Reference/Overview">
    Complete API documentation for the Sanas SDK.
  </Card>
</CardGroup>


# Quickstart
Source: https://developer.sanas.ai/Docs/Getting-Started/Quick-Start

Go from zero to processing audio: create your Sanas Console account, spin up a project, generate an API key, install the SDK, run your first inference, and watch usage and credit draw down.

# Quickstart

The Sanas Console is where you manage everything outside your code — your account, projects, API keys, credit balance, and usage. The Sanas SDK is what runs in your code: you feed it interleaved float32 PCM frames and it returns processed frames — noise-cancelled, speech-enhanced, accent-converted, or translated into another language.

This guide takes you all the way through: create an account and API key in the Console, install the SDK, process your first audio stream, then see that activity show up as usage and credit in the Console.

> **Info**
>
> **Time required:** about 10 minutes. **You need:** a work email address you can receive mail at, and a supported Python interpreter. No credit card — new accounts start with **\$10.00 in free credit**.

## What you'll build

1. **An account** — your top-level organization, identified by an **Account ID**.
2. **A project** — a workspace inside the account that owns API keys and reports its own usage.
3. **An API key** — the credential your SDK integration authenticates with.
4. **A working integration** — the SDK installed and processing your first audio stream.

***

## Part 1 · Set up in the Console

### Step 1 — Create your account

Go to [**console.sanas.ai**](https://console.sanas.ai). You'll land on the Sanas Console sign-in screen. Select **Sign up** at the bottom to switch to account creation.

<img alt="Sanas Console 'Create your account' screen with a work email field, Create account button, and Sign up with Google option" />

*Create your account — Sanas Console signup*

Enter your **work email** and select **Create account**.

<img alt="Signup screen with a work email typed into the email field" />

*Enter the work email you want the account created under*

> **Tip**
>
> Prefer single sign-on? **Sign up with Google** creates the same account without a passcode step. The rest of this guide is identical either way.

### Step 2 — Verify your email

Sanas signs you in with a one-time passcode instead of a password. Check your inbox for a 6-digit code and enter it, then select **Verify**.

<img alt="Verify your email screen showing a passcode entry field, the destination email address, a Verify button, and a resend timer" />

*Verify your email with the 6-digit passcode*

> **Note**
>
> The code is time-limited. If it lapses, use **Resend Passcode** — the link becomes available after the countdown finishes. **Change** lets you correct the address before requesting a new code.

Once verified, your account is created and you're taken straight into the Console.

### Step 3 — Check your free credit

New accounts land on **Account & Billing** — your prepaid credit wallet. Usage is metered per minute and drawn down from this balance in real time.

<img alt="Account and Billing page showing a $10.00 available balance, free credit notice, auto-reload setting, monthly spend cap, per-product rate table, and billing history" />

*Account & Billing — the prepaid credit wallet*

What's on this page:

| Section | What it tells you |
| - | - |
| **Current balance** | Credit available right now. New accounts start at **\$10.00**. |
| **Free credit notice** | Your promotional credit and its expiry date. |
| **Payment method** | Add a card (handled by Stripe) to buy more credit and enable auto-reload. |
| **Auto-reload** | Off until a card is on file. Tops the wallet back up automatically. |
| **Monthly spend cap** | A safety limit for the account, independent of auto-reload — usage and top-ups pause once you reach it in a calendar month. Editable via the pencil icon. |
| **Usage this month** | Per-product rates, minutes consumed, and cost so far. |
| **Billing history** | Every credit purchase and top-up, with invoices on Stripe. |

> **Info**
>
> Free credit is enough to start developing immediately. You only need a card when you want to purchase additional credit.

### Step 4 — Create your first project

Select **Home** in the left sidebar. On a brand-new account, the **Create your first project** dialog opens automatically.

<img alt="Create your first project modal showing the parent account, a Project Name field, and a Select Timezone dropdown" />

*The Create your first project dialog on a new account*

Fill in:

* **Project Name** — `string`, required. A name you'll recognize later, such as `My First Project`.
* **Select Timezone** — `string`, required, defaults to `(UTC) Universal`. Utilisation and usage data are aggregated on this timezone and surfaced in the Reports section. Pick the timezone your team reads reports in.

Select **Create Project**.

> **Note**
>
> Timezone affects how usage is bucketed into days in reports. Changing it later re-buckets how data is displayed, so choose deliberately up front.

### Step 5 — You're inside the project

Creating the project drops you straight into it. The left sidebar switches from account scope to **project scope** — note the **Project ID** under the project name, and the new project-only entries such as **Sub Projects** and **API Keys**.

<img alt="Project dashboard showing the project name and Project ID in the sidebar, project-scoped navigation, a Create API Key button, an audio minutes chart, and Sanas feature cards" />

*Project home — the sidebar is now scoped to the project*

> **Tip**
>
> Every project has its own **Project ID** (visible in the sidebar and under the dashboard heading, with a copy button). Keep it handy — it identifies the project in support conversations and reporting.

### Step 6 — Create an API key

From the project dashboard, select **Create API Key** in the top right.

<img alt="Create API Key modal with Name, optional Description, and an Expiry dropdown" />

*The Create API Key dialog*

* **Name** — `string`, required. How the key appears in the keys list, for example `Production Key`.
* **Description** — `string`, optional. Context — what the key is used by, and who owns it.
* **Expiry** — `enum`, defaults to `30 days`. One of **30 days**, **90 days**, **1 year**, or **No expiry**.

<img alt="Create API Key modal filled in with a name, description, and a 90 day expiry" />

*A completed API key form*

Select **Create API Key**.

> **Tip**
>
> Give each environment and each service its own key. Narrow keys are far easier to rotate or revoke than one shared key wired into everything.

### Step 7 — Copy your key and store it somewhere safe

> **Warning**
>
> **This is the only time the full key is shown.** Copy it now and store it in a secrets manager, your CI/CD secret store, or your team's password manager before you close this dialog. Sanas cannot show it to you again — if you lose it, your only option is to create a replacement key and update every integration that used the old one.

<img alt="Save Your API Key dialog showing the full key with a copy button and a warning that this is the only time the full key is shown" />

*Save Your API Key — the one-time reveal*

Use the copy icon to grab the key, paste it into your secret store, **then** select **Done**.

> **Info**
>
> **Never** commit an API key to source control, paste it into a ticket or chat, or ship it in client-side code. Load it from an environment variable or secret manager at runtime.

Your key now appears in the project's **API Keys** list — permanently masked, showing only its status, expiry, creation date, and last-used timestamp.

<img alt="API Keys list showing one active key with a masked value, expiry date, created date, and last used column" />

*The API Keys list — the key is masked from here on*

Use the **⋮** menu on any row to edit or revoke a key. The **Last used** column is the quickest way to spot keys that are no longer in service and can be retired.

***

## Part 2 · Integrate the SDK

With an API key in hand, switch from the Console to your code. The Python package ships as a **self-contained wheel**: everything the SDK needs is bundled inside it, so there's no separate native library to install.

> **Note**
>
> The SDK does not open microphones or speakers for you — you bring your own audio (from a file, socket, or media stream). You push frames in with `process_frame` and read processed frames back.

### Step 8 — Download and install the SDK

Select **Get SDK** at the bottom of the sidebar. Choose your platform and download the SDK package. The same dialog links to the full SDK usage documentation.

<img alt="Download SDK dialog with a platform selector, the SDK file name and size, a Download SDK button, and a View full documentation link" />

*Get SDK — download the package for your platform*

#### Before you begin — pick the right wheel

You only need a supported CPython interpreter and `pip` — no extra tooling required. The wheel in your archive targets the Python version named in its filename:

| Python version | Wheel tag | Notes |
| - | - | - |
| 3.10 | `cp310-cp310` | version-specific |
| 3.11 | `cp311-cp311` | version-specific |
| 3.12, 3.13, 3.14 | `cp312-abi3` | one Stable-ABI wheel covers 3.12+ |

> **Tip**
>
> Pick the archive whose `<pytag>` matches your interpreter (e.g. `cp310` for Python 3.10; `cp312` for Python 3.12 **or newer**).

#### Direct download links by platform

You can also download outside the Console:

| OS | Architecture | Python | Download |
| - | - | - | - |
| Linux | x86\_64 | 3.10–3.12+ | [Download](https://dev-sdk.sanas.ai/v2.0.1/linux/) |
| macOS | Apple Silicon (arm64) | 3.10–3.12+ | [Download](https://dev-sdk.sanas.ai/v2.0.1/macos/) |
| Windows | x86\_64 | 3.10–3.12+ | [Download](https://dev-sdk.sanas.ai/v2.0.1/windows/) |

#### Archive layout

Your archive is laid out like this:

```text theme={null}
sanas-<version>-<pytag>-<os>-<arch>/
├── examples/                    # runnable examples + shared helpers
├── sanas-<version>-….whl        # the Python wheel (one, matching <pytag>)
└── USAGE.md
```

Create a virtual environment and install the wheel from inside the extracted archive directory.

**macOS / Linux**

```bash theme={null}
# With built-in python (use the python that matches the wheel tag)
python3.10 -m venv .venv
# ...or with uv (manages the Python version; --seed adds pip)
uv venv .venv --seed --python 3.10
. .venv/bin/activate
pip install --upgrade pip
pip install sanas-*.whl
```

**Windows (PowerShell)**

```powershell theme={null}
py -3.10 -m venv .venv
.\.venv\Scripts\Activate.ps1
python -m pip install --upgrade pip
python -m pip install (Get-ChildItem sanas-*.whl).FullName
```

### Step 9 — Verify the installation

```bash theme={null}
python -c "import sanas; print('sanas', sanas.__version__)"
```

### Step 10 — Choose your capability and model

The SDK runs in one of two modes. The setup flow is identical — you always `create_sdk` → `activate_api_key` → `create_audio_processor` and wait for `PipelineState.RUNNING` — but **how you select the mode and what you get back differ**:

| | Audio Processing | Language Translation (LT) |
| - | - | - |
| **Selected by** | a **model key** on `AudioAttributes.model_name` (e.g. `SE2.2`, `AT5.2`) | the **presence of `lt_config`**; `model_name` left empty |
| **What it does** | speech enhancement, noise cancellation, accent conversion | translates speech from one language to another |
| **Returns** | processed audio frames only | translated audio frames **plus** transcript segments (via the `lt_config` callback) |
| **Extra config** | none | `LanguageTranslationConfig(language_in, language_out, …)` |
| **Latency** | low (\~tens of ms) — short tail drain | higher (\~seconds) — drain with a longer silence window |

For audio processing, set `model_name` to one of the model keys enabled for your account:

| Category | Model keys |
| - | - |
| Agentic Speech Enhancement | `AGENTIC_ST_SE`, `AGENTIC_VI_GT_SE`, `AGENTIC_VI_G_SE` |
| Accent Translation (AT) | `AT5.2` |
| Speech Enhancement | `SE1.2`, `SE2.1`, `SE2.2`, `VI_G_SE` |

> **Note**
>
> This page covers Language Translation **inside the Python SDK** (selected via `lt_config`). Sanas also offers a standalone, browser-friendly [Language Translation API](/Docs/Language-Translation/Overview) (JavaScript client) for real-time speech-to-speech in the browser — use that instead of the SDK if you're building a web app.

### Step 11 — Process your first audio stream

Two things to understand before reading the code:

* **The pipeline initializes asynchronously.** After you create a processor, wait for `PipelineState.RUNNING` (via the `audio_pipeline_state_notify` callback) before feeding frames.
* **`process_frame` is synchronous but expects real-time audio.** Feed frames at the rate they would arrive live (one 20 ms frame every 20 ms). The snippets below pace with a monotonic-clock deadline so timing doesn't drift.

The two sections below show the **only difference between the modes**: Audio Processing sets a `model_name`; Language Translation leaves it empty and passes an `lt_config` instead. Pass the API key you copied in [Step 7](#step-7-—-copy-your-key-and-store-it-somewhere-safe) as `YOUR_API_KEY`.

#### Option A — Audio Processing

Create `sdk_example.py` and set `model_name` to one of your enabled model keys.

```python theme={null}
import array
import threading
import time
import sanas
from examples.wav_utils import read_wav, save_wav  # or copy these helpers

# 1. Create + activate (activation is synchronous and returns an SdkResult).
sdk = sanas.create_sdk(sanas.InitParams(storage_dir="./storage"))
res = sdk.activate_api_key("YOUR_API_KEY")
if not res.success:
    raise RuntimeError(f"activation failed ({res.error_type}): {res.message}")

# 2. Read input audio as interleaved float32.
float32_bytes, sample_rate, channels = read_wav("input.wav")
samples = array.array("f"); samples.frombytes(float32_bytes)

# 3. Get notified when the pipeline is ready. The state callback fires on a
#    background thread, so publish each state under a Condition and let the
#    main thread wait for a terminal state (RUNNING = go, NOT_RUNNING = failed).
cond = threading.Condition()
state = {"value": None}
def on_state(s):
    with cond:
        state["value"] = s
        cond.notify_all()

attrs = sanas.ProcessorAttributes(
    audio_attributes=sanas.AudioAttributes(
        sampling_rate=sample_rate,
        channels=channels,
        model_name="<your-model-key>",  # e.g. "AT5.2", "SE2.2", "VI_G_SE"
        audio_pipeline_state_notify=on_state,
    )
)

# 4. Feed 20 ms frames at real time; process_frame returns the processed frame.
frame_len = sample_rate * channels // 50  # samples in 20 ms
frame_period = 0.020  # seconds per frame
out_bytes = []
_terminal = (sanas.PipelineState.RUNNING, sanas.PipelineState.NOT_RUNNING)
with sdk.create_audio_processor(attrs) as proc:
    with cond:  # wait until the pipeline settles
        cond.wait_for(lambda: state["value"] in _terminal, timeout=30)
        if state["value"] != sanas.PipelineState.RUNNING:
            raise RuntimeError(f"pipeline did not start (state: {state['value']})")

    # `deadline` is the wall-clock time the NEXT frame should be sent.
    deadline = time.monotonic()
    for i in range(0, len(samples) - frame_len + 1, frame_len):
        frame = proc.process_frame(sanas.AudioFrame(samples=samples[i:i + frame_len]))
        if frame.frame_count:
            out_bytes.append(bytes(frame.samples))  # memoryview is transient; copy
        deadline += frame_period
        time.sleep(max(0.0, deadline - time.monotonic()))

    # Drain the buffered tail by pushing silence (still paced at real time).
    silence = array.array("f", bytes(frame_len * 4))
    for _ in range(10):
        frame = proc.process_frame(sanas.AudioFrame(samples=silence))
        if frame.frame_count:
            out_bytes.append(bytes(frame.samples))
        deadline += frame_period
        time.sleep(max(0.0, deadline - time.monotonic()))

save_wav("output.wav", b"".join(out_bytes), sample_rate, channels)
```

> **Tip**
>
> `examples/helpers.py` provides `PipelineWaiter`, `sleep_until`, and `feed_and_drain`, which wrap steps 3–4 above — prefer them over hand-rolling the loop.

#### Option B — Language Translation

Language Translation is selected by the **presence of `lt_config`** (not by a model key), so leave `model_name` empty. Translated audio comes back from `process_frame`; transcripts arrive on the `lt_config` callback.

```python theme={null}
import array
import threading
import time
import sanas
from examples.wav_utils import read_wav, save_wav

sdk = sanas.create_sdk(sanas.InitParams(storage_dir="./storage"))
res = sdk.activate_api_key("YOUR_API_KEY")
if not res.success:
    raise RuntimeError(f"activation failed ({res.error_type}): {res.message}")

float32_bytes, sample_rate, channels = read_wav("input.wav")
samples = array.array("f"); samples.frombytes(float32_bytes)

def on_transcript(tf):
    kind = "Translation" if tf.type_ == sanas.TranscriptType.TRANSLATION else "Transcription"
    for seg in tf.transcript_data_.complete:
        print(f"[{kind}] {seg.text}")

cond = threading.Condition()
state = {"value": None}
def on_state(s):
    with cond:
        state["value"] = s
        cond.notify_all()

attrs = sanas.ProcessorAttributes(
    audio_attributes=sanas.AudioAttributes(
        sampling_rate=sample_rate,
        channels=channels,
        model_name="",  # LT is selected by lt_config, not a key
        audio_pipeline_state_notify=on_state,
    ),
    lt_config=sanas.LanguageTranslationConfig(
        language_in="en-US",
        language_out="es-ES",
        conversation_id="",  # optional; links two-party sessions
        callback=on_transcript,
    ),
)

frame_len = sample_rate * channels // 50  # samples in 20 ms
frame_period = 0.020  # seconds per frame
out_bytes = []
_terminal = (sanas.PipelineState.RUNNING, sanas.PipelineState.NOT_RUNNING)
with sdk.create_audio_processor(attrs) as proc:
    with cond:
        cond.wait_for(lambda: state["value"] in _terminal, timeout=30)
        if state["value"] != sanas.PipelineState.RUNNING:
            raise RuntimeError(f"pipeline did not start (state: {state['value']})")

    deadline = time.monotonic()
    for i in range(0, len(samples) - frame_len + 1, frame_len):
        frame = proc.process_frame(sanas.AudioFrame(samples=samples[i:i + frame_len]))
        if frame.frame_count:
            out_bytes.append(bytes(frame.samples))
        deadline += frame_period
        time.sleep(max(0.0, deadline - time.monotonic()))

    # Translation adds several seconds of latency, so keep pushing silence for a
    # few seconds after the input ends to pull back the translated tail.
    silence = array.array("f", bytes(frame_len * 4))
    for _ in range(int(5.0 / frame_period)):  # ~5 s of silence
        frame = proc.process_frame(sanas.AudioFrame(samples=silence))
        if frame.frame_count:
            out_bytes.append(bytes(frame.samples))
        deadline += frame_period
        time.sleep(max(0.0, deadline - time.monotonic()))

save_wav("translated.wav", b"".join(out_bytes), sample_rate, channels)
```

> **Note**
>
> Because translation runs speech-to-text, translation, and text-to-speech end to end, it adds several seconds of latency. Keep the extended silence-drain loop (\~5 s) so the translated tail is pulled back after your input ends — this is the main runtime difference from audio processing.

> **Tip**
>
> Building for the browser instead of a Python backend? Use the standalone [Language Translation API](/Docs/Language-Translation/Overview) (JavaScript client) rather than the SDK path shown here.

#### Cloud inference tuning (optional)

When the SDK runs on cloud / remote inference (the default), you can pass a `CloudInferencingParams` on `AudioAttributes.cloud_inferencing_params` to tune the remote path. These parameters are **only meaningful for cloud inference and are ignored for local inference**. The field is optional — omit it to keep the defaults.

| Field | Type | Default | Meaning |
| - | - | - | - |
| `use_pcm16` | `bool` | `False` | Negotiate L16 (raw 16-bit linear PCM) at the session sample rate instead of the rate-default codec. Preserves fidelity and avoids server-side transcoding, at the cost of more bandwidth. |

```python theme={null}
cloud_params = sanas.CloudInferencingParams()
cloud_params.use_pcm16 = True  # opt into raw 16-bit linear PCM uplink
attrs = sanas.ProcessorAttributes(
    audio_attributes=sanas.AudioAttributes(
        sampling_rate=sample_rate,
        channels=channels,
        model_name="<your-model-key>",
        cloud_inferencing_params=cloud_params,  # optional; omit for defaults
        audio_pipeline_state_notify=on_state,
    )
)
```

> **Note**
>
> Leave `cloud_inferencing_params` unset (or `use_pcm16=False`) unless you specifically need raw PCM uplink — the rate-default codec is the recommended default for most sessions.

Once the SDK is initialized with a valid key and a model, you can start running inference. Every stream you process is metered against the project that owns the key.

### Step 12 — Run the examples

The `examples/` folder is self-contained (standard-library helpers only, no numpy). With your venv active, set the required environment variables and run an example from inside the extracted archive:

```bash theme={null}
export SANAS_API_KEY="your-key"
export SANAS_STORAGE_DIR=./storage         # SDK data + logs (created if missing)
export SANAS_INPUT_WAV=input.wav           # 16-bit PCM or 32-bit float WAV
python examples/sdk_example.py             # audio processing
python examples/language_translation_example.py   # language translation
python examples/multi_stream_example.py --streams 4   # concurrency benchmark
```

> **Note**
>
> `SANAS_STORAGE_DIR` is where the SDK keeps its data and writes logs (under `storage_dir/logs`).

***

## Part 3 · Monitor usage and manage the account

### Step 13 — Switch between projects and your account

The Console has two scopes, and knowing how to move between them is the key to reading your data correctly.

* **Account scope** — everything across **all** projects: total usage, the credit wallet, billing, team, and account settings.
* **Project scope** — one project only: its API keys, sub projects, connected clients, and its own usage.

To switch, select the **name card at the top of the sidebar**. The account sits at the top of the dropdown, with its projects nested beneath it. Choose the account to go account-wide, or any project to scope down. The same switcher is available from the breadcrumb in the header.

<img alt="Sidebar switcher expanded showing the account row with the project nested underneath, a project search field, and a Create Project button" />

*The switcher — account on top, projects nested beneath*

> **Tip**
>
> The dropdown also holds **Search Projects…** and **+ Create Project**, so this is the fastest way to add projects two and beyond — the automatic first-project dialog only appears once.

You can also browse every project from **Projects** in the account sidebar, which shows each project's ID, API key count, connected clients, and creation date.

<img alt="Projects list showing project name, Project ID, connected clients, API keys, users, and created date, with a Create Project button" />

*The Projects list at account scope*

### Step 14 — Watch usage and credit move

Once inference is running through the SDK, the Console reflects it in two places.

#### Usage in the project

Open **Usage** inside the project to see only what that project's keys processed — streams processed, audio minutes, and average stream duration, with charts over time. Filter by product and by date range.

<img alt="Project Usage page showing 12 streams processed, 14 minutes of audio processed, and a 1m 11s average stream duration, above two time-series charts with a single-day spike" />

*Project-scoped usage — 12 streams, 14 minutes of audio*

#### Usage across the account

Now switch to the **account** using the sidebar switcher and open **Usage** there. Same metrics, aggregated across **every** project — this is the number to watch as you add projects.

<img alt="Account-level Usage page showing aggregated streams processed, audio minutes processed, and average stream duration across all projects" />

*Account-scoped usage, aggregated across all projects*

> **Tip**
>
> With a single project the two views match. Once you add projects, the account view is the only place the totals line up — a project view can never show you the whole bill.

#### Credit drawing down

Back on **Account & Billing**, the same activity shows up as money. Compare this with the fresh wallet in Step 3 — the balance has moved from $10.00** to **$**9.76**:

* **Current balance** drops as minutes are processed.
* **Spent this cycle** rises to match.
* **Usage this month** breaks the spend out per product, at each product's per-minute rate — here 14m 12s of audio costing \$0.24 in total.

<img alt="Account and Billing page showing a reduced balance of 9.76, 0.24 spent this cycle, and a usage table breaking 14m 12s of processing down across four products" />

*The wallet after processing — balance down, spend broken out per product*

Because rates differ sharply per product, minutes alone don't tell you the cost — the same two minutes cost \$0.18 on Language Translation but under a cent on Cloud Speech Enhancement. Use the **Cost** column, not the **Usage** column, to see where your credit actually goes.

> **Info**
>
> Usage is metered per minute and drawn down in real time, so a burst of inference is visible on both the Usage pages and the wallet shortly after it runs. Reporting is aggregated on the **timezone you chose when creating the project**.

> **Note**
>
> **Usage this month** is scoped to the current calendar month, so it resets on the 1st while **Current balance** keeps falling across months. If the balance has dropped but this panel reads `$0.00`, the processing happened in an earlier period — widen the range on the **Usage** page to find it.

> **Warning**
>
> When credits run out, the wallet status flips to **Paused** — paid usage stops until you add credits. Add a payment method and turn on **auto-reload** before you depend on Sanas in production, so a busy day can't interrupt your service.

***

## Signing back in

Return to [console.sanas.ai](https://console.sanas.ai) any time. Enter your email, select **Continue**, and verify with a fresh passcode — or use **Google** if that's how you signed up.

<img alt="Sanas Console sign in screen with an email field, Continue button, Google sign-in option, and a Sign up link" />

*The Sanas Console sign-in screen*

## Key SDK types

`InitParams`, `create_sdk`, `Sdk`, `AudioAttributes`, `ProcessorAttributes`, `AudioProcessor`, `AudioFrame`, `LanguageTranslationConfig`, `CloudInferencingParams`, `PipelineState`, `SdkResult`.

## Troubleshooting

### The passcode never arrived

Check spam and any corporate mail filtering. Wait for the resend countdown to finish, then select **Resend Passcode**. Use **Change** to correct a typo in the address rather than requesting more codes to the wrong inbox.

### I closed the dialog before copying my key

The full key is unrecoverable by design. Create a new key, update your integration, and revoke the old one from the **⋮** menu in the API Keys list.

### The first-project dialog didn't appear

It only opens automatically for accounts with no projects. Use **Projects → Create Project**, or **+ Create Project** in the sidebar switcher.

### I don't see the API Keys entry

You're at account scope. API keys belong to a project — select a project in the sidebar switcher, then choose **API Keys**.

### `import sanas` fails or the wheel won't install

Confirm the wheel tag matches your interpreter (`cp310` for Python 3.10; `cp312-abi3` for 3.12+). Install from **inside** the extracted archive so `pip install sanas-*.whl` resolves the bundled wheel, and make sure your venv is activated first.

### The pipeline never reaches RUNNING

Activation and model selection are the usual causes. Check that `activate_api_key` returned `success`, that `model_name` is a key enabled for your account (or that `lt_config` is set for Language Translation), and that you waited on the `audio_pipeline_state_notify` callback before feeding frames.

### My usage still reads zero

Confirm the date-range filter covers when you ran inference, and that you're looking at the project whose key the SDK is using. Check at account scope to rule out having run against a different project. Usage is aggregated on the project's configured timezone, so very recent activity may sit in the current day's bucket.

### Processing stopped unexpectedly

Check **Account & Billing**. If the status pill reads **Paused**, either credits ran out or the **monthly spend cap** was reached for the calendar month. Add credits to resume, or raise the cap with the pencil icon next to it.

***

## Next steps

* [**Process multiple streams**](/Docs/Tutorials/Processing-Multiple-Streams) — scale to multiple concurrent audio streams with a shared SDK instance.
* [**Add your team**](https://console.sanas.ai) — invite teammates from **Team** and give them access to the account or an individual project.
* [**Add a payment method**](https://console.sanas.ai/billing/credits) — put a card on file to purchase credit and enable auto-reload before free credit runs out.
* **Organize with sub projects** — split a project into sub projects to separate environments or customers while keeping usage rolled up.

## Need help?

* **Email Support** — [support@sanas.ai](mailto:support@sanas.ai) · Response time: 1 business day
* **Support Portal** — raise a [support ticket](https://support.sanas.ai/support/home) for urgent issues.


# Language Translation
Source: https://developer.sanas.ai/Docs/Language-Translation/Overview

Add real-time speech-to-speech translation to your application using Sanas SDK

### How Language Translation Works

Sanas Language Translation turns speech in one language into natural-sounding speech in another, in real time. You send audio in, and you get translated audio back — along with the text of what was said and what it was translated to.

Access is enabled through the **Sanas Developer Console**. Once Language Translation is turned on for your account there, you'll generate an API key and pick the languages you want to translate between. No separate installation or infrastructure is required on your side.

Under the hood, each session follows a simple round trip:

1. **Your app captures audio** — from a microphone or an audio file — and opens a connection to the Sanas cloud using WebRTC or WebSocket (or the Sanas JavaScript client, which handles the connection for you).
2. **You choose a language route**, such as English → Spanish, and the session starts once the service confirms it's ready.
3. **Sanas processes the speech in the cloud**: it transcribes what was said (speech-to-text), translates the text into the target language, and generates spoken audio in a natural voice (text-to-speech).
4. **Translated audio streams back to your app**, ready to play, along with live transcription and translation text you can display on screen.

The whole loop happens continuously and with low latency, so conversations feel natural rather than stop-and-start. Because everything runs as a managed cloud service, you get updates, new languages, and scaling automatically — you only manage your API key and language settings in the Developer Console.

## Supported Languages:

| Current Supported Languages | Code |
| - | - |
| Arabic | ar-SA |
| Czech | cs-CZ |
| Danish (Beta) | da-DK |
| Dutch | nl-NL |
| English (US) | en-US |
| English (UK) | en-GB |
| Finnish (Beta) | fi-FI |
| French | fr-FR |
| French (Canadian) | fr-CA |
| German | de-DE |
| Greek | el-GR |
| Hindi | hi-IN |
| Hungarian | hu-HU |
| Indonesian | id-ID |
| Italian | it-IT |
| Japanese (Beta) | ja-JP |
| Korean | ko-KR |
| Malay | ms-MY |
| Mandarin | zh-CN |
| Polish | pl-PL |
| Portuguese (Brazilian) | pt-BR |
| Portuguese (Portugal) | pt-PT |
| Romanian | ro-RO |
| Russian | ru-RU |
| Spanish (Spain) | es-ES |
| Spanish (Latin America) | es-419 |
| Swedish | sv-SE |
| Tagalog (Beta) | tl-PH |
| Thai | th-TH |
| Turkish | tr-TR |

## Try Language Translation

[Quick Start](/Docs/Getting-Started/Quick-Start#option-b-—-language-translation)


# Choose Your Model
Source: https://developer.sanas.ai/Docs/Models/Choose-Your-Model

Find the right Sanas model for your use case

Not sure which model to use? Answer one question to find the right fit. SDKs will be available for download in Self serve mode from [Developer Console](https://www.sanas.ai/developer-platform).

## Who is listening?

<CardGroup>
  <Card title="A person is listening" icon="users">
    You need a **Human ↔ Human** model. Voice quality and naturalness matter.
  </Card>

  <Card title="A machine is listening" icon="robot">
    You need a **Human ↔ Machine** model. Relative Word Error Rate (RWERR) reduction and ASR accuracy matter.
  </Card>
</CardGroup>

## Human ↔ Human

| Model | Model Name | Scenario | Description |
| - | - | :- | - |
| Speech Enhancement · Voice Isolation (General)<br /> | `VI_G_SE` | Noisy environment, human listener | SE · Voice Isolation (General)<br /> |
| Speech Enhancement Standard<br /> | `SE2.1` | Telephony audio restoration, low CPU | Restores and enhances voice quality, outputs 8kHz |
| Speech Enhancement with Full-Fidelity<br /> | `SE2.2` | Full-fidelity audio restoration | Bandwidth extension to ultra-fidelity 24kHz |
| Accent Translation<br /> | `AT5.2` | Accent Normalization | Add Accent Translation to your application to modifies global accents in real-time, allowing your teams to be instantly understood. |
| Language Translation<br /> | [LT](/Docs/Language-Translation/Overview) | Voice-preserving Language translation | Add real-time speech-to-speech language translation to your application that preserves your speakers' voices, tone, and intent. |

## Human ↔ Machine

| Model | Model Name | Scenario | Description |
| - | - | - | - |
| Agentic SE · Voice Isolation (General) | `AGENTIC_VI_G_SE` | Single speaker → ASR (16kHz) | Removes environmental noise and distant human voices. Single-speaker isolation for voice agents, IVR, phone bots |
| Agentic SE · Voice Isolation (Telephony) | `AGENTIC_VI_GT_SE` | Single speaker → ASR (8kHz telephony) | Telephony-optimized variant of Voice Isolation for 8kHz narrowband audio |
| Agentic SE · Standard | `AGENTIC_ST_SE` | Multiple speakers → ASR | Agentic SE · StandardRemoves environmental noise, preserves distant human speech. Multi-speaker environments where background conversations carry context |

<Tip>
  More models and model updates are coming soon.
</Tip>

## Still Not Sure?

Explore audio samples, full specifications, use cases, and code examples:

<CardGroup>
  <Card title="Speech Enhancement · Voice Isolation (General)" icon="volume-slash" href="/Docs/Models/Human-Human/SE-Voice-Isolation">
    **`VI_G_SE`**

    Isolates intended speech by removing background noise and voices. Optimized for human listeners.
  </Card>

  <Card title="Speech Enhancement · Standard" icon="microphone" href="/Docs/Models/Human-Human/SE-Standard">
    **`SE2.1`**

    Restores and enhances voice quality for telephony audio. Low CPU footprint.
  </Card>

  <Card title="Speech Enhancement · Full Fidelity" icon="microphone" href="/Docs/Models/Human-Human/SE-Full-Fidelity">
    **`SE2.2`**

    Full-fidelity speech enhancement with bandwidth extension to ultra-fidelity 24kHz.
  </Card>

  <Card title="Agentic Speech Enhancement · Voice Isolation (General)" icon="robot" href="/Docs/Models/Human-Machine/Agentic-SE-Voice-Isolation">
    **`AGENTIC_VI_G_SE`**

    Removes background noise and distant voices for complete voice isolation of the primary speaker's audio stream.
  </Card>

  <Card title="Agentic Speech Enhancement · Voice Isolation (Telephony)" icon="robot" href="/Docs/Models/Human-Machine/Agentic-Speech-Enhancement/Agentic-SE-Voice-Isolation-Telephony">
    **`AGENTIC_VI_GT_SE`**

    Telephony-optimized variant of Voice Isolation for 8kHz narrowband audio.
  </Card>

  <Card title="Agentic Speech Enhancement · Standard" icon="robot" href="/Docs/Models/Human-Machine/Agentic-Speech-Enhancement/Agentic-SE-Standard">
    **`AGENTIC_ST_SE`**

    Removes background noise while preserving all human speech for multi-speaker environments.
  </Card>

  <Card title="Accent Translation" icon="robot" href="/Docs/Models/Human-Human/Accent-Translation/Accent-Translation">
    `AT5.2`

    Accent Translation modifies global accents in real-time, allowing your teams to be instantly understood while preserving what makes every voice unique.
  </Card>

  <Card title="Language Translation" icon="robot" href="/Docs/Language-Translation/Overview">
    [LT](/Docs/Language-Translation/Overview)

    Real-time language translation that preserves your speakers' voices, tone, and intent.
  </Card>
</CardGroup>


# Accent Translation AT 5.2
Source: https://developer.sanas.ai/Docs/Models/Human-Human/Accent-Translation/Accent-Translation

Real-time accent modulation that preserves voice identity and emotion.

Accent Translation modifies global accents in real time, allowing speakers to be instantly understood while preserving what makes every voice unique. It refines how accented speech is heard — improving clarity and comprehension the first time — without stripping away the heritage, tone, or emotion that make a voice human.

### Key Features

<CardGroup>
  <Card title="Improves understanding" icon="language">
    Refines how accented speech is heard so listeners understand clearly the first time — no repetition or clarification.
  </Card>

  <Card title="Preserves voice identity" icon="microphone">
    Keeps the speaker's natural voice, tone, and emotion intact. Every conversation stays authentic and human.
  </Card>

  <Card title="Real-time, low cost" icon="bolt">
    No perceptible delay means no awkward pauses or conversational resets. Low compute cost for high concurrency.
  </Card>
</CardGroup>

## Specifications

**Model ID:** `AT5.2` <br />**Category:** Accent Translation<br />**Type:** Human ↔ Human

<CardGroup>
  <Card title="Real-time" icon="bolt">
    Streaming latency
  </Card>

  <Card title="24kHz" icon="waveform-lines">
    Max sample rate
  </Card>

  <Card title="US / UK" icon="globe">
    Output accents
  </Card>
</CardGroup>

## Use Cases

<CardGroup>
  <Card title="Contact Centers" icon="headset">
    Agent-customer calls. Instant clarity that improves CSAT, QA scores, and first-call resolution.
  </Card>

  <Card title="Financial Services" icon="building-columns">
    Build trust and clarity in every conversation so customers move forward with confidence.
  </Card>

  <Card title="Healthcare" icon="stethoscope">
    Deliver clarity and empathy from the very first patient or member interaction.
  </Card>

  <Card title="Travel & Retail" icon="plane">
    Turn frustrated moments into loyal relationships through clear, natural communication.
  </Card>
</CardGroup>

## Code Example

Create an audio processor with the Accent Translation model:

```python theme={null}
attrs = sanas.ProcessorAttributes(
      audio_attributes=sanas.AudioAttributes(
                sampling_rate=16000,
                channels=1,
                model_name="AT5.2",
                audio_pipeline_state_notify=on_state,
      )
)

with sdk.create_audio_processor(attrs) as proc:
      ...
```

For full setup and initialization, see the [Quick Start →](/Docs/Getting-Started/Quick-Start)

## Next Steps

<CardGroup>
  <Card title="Quick Start" icon="rocket" href="/Docs/Getting-Started/Quick-Start">
    Get up and running with Sanas SDK in under 5 minutes.
  </Card>

  <Card title="API Reference" icon="book" href="/API-Reference/Overview">
    Full SDK documentation for classes, enums, and callbacks.
  </Card>

  <Card title="Processing Multiple Streams" icon="layer-group" href="/Docs/Tutorials/Processing-Multiple-Streams">
    Handle multiple concurrent audio streams.
  </Card>
</CardGroup>


# SE 2.2 with Full-Fidelity
Source: https://developer.sanas.ai/Docs/Models/Human-Human/SE-Full-Fidelity

Real-time speech enhancement with bandwidth extension to 24kHz ultra-fidelity audio

The Speech Enhancement Ultra (`SE2.2`) model delivers full-fidelity speech enhancement with bandwidth extension. It takes 16kHz input and outputs ultra-fidelity 24kHz audio, performing all the restorative capabilities of SE Standard while extending bandwidth for a richer, more natural listening experience — designed for environments with larger CPU budgets.

## Hear the Difference

### Various Accents

<div>
  <div>
    **Before** · Original audio

    <video />
  </div>

  <div>
    **After** · Enhanced with SE Ultra

    <video />
  </div>
</div>

### Codec Degradation

<div>
  <div>
    **Before** · Original audio

    <video />
  </div>

  <div>
    **After** · Enhanced with SE Ultra

    <video />
  </div>
</div>

### Packet Loss

<div>
  <div>
    **Before** · Original audio

    <video />
  </div>

  <div>
    **After** · Enhanced with SE Ultra

    <video />
  </div>
</div>

### Overlapping Speech

<div>
  <div>
    **Before** · Original audio

    <video />
  </div>

  <div>
    **After** · Enhanced with SE Ultra

    <video />
  </div>
</div>

### Background Noise

<div>
  <div>
    **Before** · Original audio

    <video />
  </div>

  <div>
    **After** · Enhanced with SE Ultra

    <video />
  </div>
</div>

## Key Features

<CardGroup>
  <Card title="Bandwidth Extension" icon="arrow-up-right-dots">
    Extends audio to ultra-fidelity 24kHz for a richer, more natural voice experience beyond standard telephony quality.
  </Card>

  <Card title="Removes Noise and Speech" icon="volume-slash">
    Eliminates background noises and background speech while preserving the primary speaker.
  </Card>

  <Card title="Restores Voice Fidelity" icon="microphone">
    Restores foreground voice to high-fidelity, enhancing clarity, articulation, energy, and vocal presence.
  </Card>

  <Card title="Corrects Degradation" icon="wrench">
    Fixes codec degradation, packet loss from poor connections, reverb, and room acoustics.
  </Card>
</CardGroup>

## Specifications

**Model ID:** `SE2.2`<br />**Category:** Speech Enhancement<br />**Type:** Human ↔ Human

<CardGroup>
  <Card title="160ms" icon="bolt">
    Streaming latency
  </Card>

  <Card title="16kHz → 24kHz" icon="waveform-lines">
    Input / Output sample rate
  </Card>
</CardGroup>

<Note>
  Remote Server currently outputs at 16kHz. Full 24kHz output support coming soon.
</Note>

## Use Cases

<CardGroup>
  <Card title="Contact Centers" icon="headset">
    Premium voice quality for agent-customer calls where clarity and presence matter most.
  </Card>

  <Card title="Conferencing" icon="users">
    Ultra-fidelity audio for video conferences and virtual meetings.
  </Card>

  <Card title="Voice Recording" icon="circle-dot">
    Restore and upscale archived or degraded voice recordings to studio-like quality.
  </Card>

  <Card title="Telemedicine" icon="stethoscope">
    Crystal-clear audio for doctor-patient consultations where every word counts.
  </Card>
</CardGroup>

<Note>
  **Known Limitations**

  * Speaker identity may occasionally differ slightly from the original.
  * Although pronunciations are unchanged, there may be a subtle perception of an Americanized accent.
  * Requires a larger CPU budget compared to SE Standard (`SE2.1`).
</Note>

## Code Example

Create an audio processor with the SE Ultra model:

```python theme={null}
attrs = sanas.ProcessorAttributes(
      audio_attributes=sanas.AudioAttributes(
                sampling_rate=16000,
                channels=1,
                model_name="SE2.2",
                audio_pipeline_state_notify=on_state,
      )
)

with sdk.create_audio_processor(attrs) as proc:
      ...
```

<Info>
  Input sample rate: 16 kHz. The model outputs 24 kHz ultra-fidelity, but Sanas Cloud downsamples it to 16 kHz to match the input sample rate.
</Info>

For full setup and initialization, see the [Quick Start →](/Docs/Getting-Started/Quick-Start)

## Next Steps

<CardGroup>
  <Card title="Quick Start" icon="rocket" href="/Docs/Getting-Started/Quick-Start">
    Get up and running with Sanas SDK in under 5 minutes.
  </Card>

  <Card title="API Reference" icon="book" href="/API-Reference/Overview">
    Full SDK documentation for classes, enums, and callbacks.
  </Card>

  <Card title="Processing Multiple Streams" icon="layer-group" href="/Docs/Tutorials/Processing-Multiple-Streams">
    Handle multiple concurrent audio streams.
  </Card>
</CardGroup>


# SE 2.1 - Standard
Source: https://developer.sanas.ai/Docs/Models/Human-Human/SE-Standard

Real-time speech enhancement optimized for 8kHz telephony audio

The Speech Enhancement Standard (`SE2.1`) model restores and enhances voice quality for telephony audio. It takes 16kHz input and outputs high-fidelity 8kHz audio, correcting codec degradation, packet loss, reverb, and background noise — purpose-built for contact center and telephony environments with limited CPU budgets.

## Hear the Difference

### Various Accents

<div>
  <div>
    **Before** · Original audio

    <video />
  </div>

  <div>
    **After** · Enhanced with SE Standard

    <video />
  </div>
</div>

### Codec Degradation

<div>
  <div>
    **Before** · Original audio

    <video />
  </div>

  <div>
    **After** · Enhanced with SE Standard

    <video />
  </div>
</div>

### Packet Loss

<div>
  <div>
    **Before** · Original audio

    <video />
  </div>

  <div>
    **After** · Enhanced with SE Standard

    <video />
  </div>
</div>

### Overlapping Speech

<div>
  <div>
    **Before** · Original audio

    <video />
  </div>

  <div>
    **After** · Enhanced with SE Standard

    <video />
  </div>
</div>

### Background Noise

<div>
  <div>
    **Before** · Original audio

    <video />
  </div>

  <div>
    **After** · Enhanced with SE Standard

    <video />
  </div>
</div>

## Key Features

<CardGroup>
  <Card title="Removes Noise and Speech" icon="volume-slash">
    Eliminates background noises and background speech while preserving the primary speaker.
  </Card>

  <Card title="Restores Voice Fidelity" icon="microphone">
    Restores foreground voice to high-fidelity, enhancing clarity, articulation, energy, and vocal presence.
  </Card>

  <Card title="Corrects Degradation" icon="wrench">
    Fixes codec degradation, packet loss from poor connections, reverb, and room acoustics.
  </Card>

  <Card title="Low CPU Footprint" icon="microchip">
    Designed for production environments with limited CPU resources.
  </Card>
</CardGroup>

## Specifications

**Model ID:** `SE2.1`<br />**Category:** Speech Enhancement<br />**Type:** Human ↔ Human

<CardGroup>
  <Card title="120ms" icon="bolt">
    Streaming latency
  </Card>

  <Card title="16kHz → 8kHz" icon="waveform-lines">
    Input / Output sample rate
  </Card>
</CardGroup>

## Use Cases

<CardGroup>
  <Card title="Contact Centers" icon="headset">
    Enhance agent-customer call quality in telephony environments with limited bandwidth.
  </Card>

  <Card title="Telephony Systems" icon="phone">
    Restore voice clarity for 8kHz telephony pipelines degraded by compression and network conditions.
  </Card>

  <Card title="IVR Systems" icon="phone-volume">
    Improve audio quality for automated phone systems operating on narrowband audio.
  </Card>

  <Card title="Voice Recording" icon="circle-dot">
    Clean up and restore archived or low-quality voice recordings.
  </Card>
</CardGroup>

<Note>
  **Known Limitations**

  * Speaker identity may occasionally differ slightly from the original.
  * Although pronunciations are unchanged, there may be a subtle perception of an Americanized accent.
</Note>

## Code Example

Create an audio processor with the SE Standard model:

```python theme={null}
attrs = sanas.ProcessorAttributes(
      audio_attributes=sanas.AudioAttributes(
                sampling_rate=16000,
                channels=1,
                model_name="SE2.1",
                audio_pipeline_state_notify=on_state,
      )
)

with sdk.create_audio_processor(attrs) as proc:
      ...
```

<Info>
  Input sample rate: 16 kHz. The model outputs 8 kHz optimized for telephony, but Sanas Cloud upsamples it to 16 kHz to match the input sample rate.
</Info>

For full setup and initialization, see the [Quick Start →](/Docs/Getting-Started/Quick-Start)

## Next Steps

<CardGroup>
  <Card title="Quick Start" icon="rocket" href="/Docs/Getting-Started/Quick-Start">
    Get up and running with Sanas SDK in under 5 minutes.
  </Card>

  <Card title="API Reference" icon="book" href="/API-Reference/Overview">
    Full SDK documentation for classes, enums, and callbacks.
  </Card>

  <Card title="Processing Multiple Streams" icon="layer-group" href="/Docs/Tutorials/Processing-Multiple-Streams">
    Handle multiple concurrent audio streams.
  </Card>
</CardGroup>


# SE 1.0 - Voice Isolation
Source: https://developer.sanas.ai/Docs/Models/Human-Human/SE-Voice-Isolation

Real-time voice isolation for any acoustic environment.

The Voice Isolation SE 1.0 (`VI_G_SE`) is a best-in-class model for denoising audio and clarifying speech. It extracts voices from any noisy environment in real time, removing unwanted background noise and background speech while preserving natural voice quality. With low latency and minimal computing cost, SE delivers clean speech waveforms suitable for human communication.

## Hear the Difference

Voice Isolation SE preserves only the primary speaker by removing background voices, noise, and chatter.

<div>
  <div>
    **Before** · Primary speaker + background noise

    <video />
  </div>

  <div>
    **After** · Primary speaker only

    <video />
  </div>
</div>

## Key Features

<CardGroup>
  <Card title="Removes background noise" icon="volume-slash">
    Environmental noise, background speech, HVAC, keyboard, traffic — all removed without affecting the primary speaker.
  </Card>

  <Card title="Preserves voice quality" icon="microphone">
    Natural voice quality preservation. Optimized for single-speaker scenarios.
  </Card>

  <Card title="Real-time, low cost" icon="bolt">
    Minimal latency across any acoustic environment. Low compute cost for high concurrency.
  </Card>
</CardGroup>

## Specifications

**Model ID:** `VI_G_SE`<br />**Category:** Speech Enhancement<br />**Type:** Human ↔ Human

<CardGroup>
  <Card title="~40ms" icon="bolt">
    Streaming latency
  </Card>

  <Card title="24kHz" icon="waveform-lines">
    Max sample rate
  </Card>

  <Card title="~1m" icon="signal">
    Primary speaker range
  </Card>
</CardGroup>

## Use Cases

<CardGroup>
  <Card title="Contact Centers" icon="headset">
    Agent-customer calls. Clear communication in noisy call centers.
  </Card>

  <Card title="Remote Work" icon="laptop">
    Video conferences. Professional audio from home offices.
  </Card>

  <Card title="Gaming" icon="gamepad">
    Voice chat. Crystal-clear team communication.
  </Card>

  <Card title="Telemedicine" icon="stethoscope">
    Doctor-patient calls. Private, distraction-free consultations.
  </Card>
</CardGroup>

## Code Example

Create an audio processor with the Voice Isolation SE model:

```python theme={null}
attrs = sanas.ProcessorAttributes(
      audio_attributes=sanas.AudioAttributes(
                sampling_rate=16000,  # Or up to 24kHz
                channels=1,
                model_name="VI_G_SE",
                audio_pipeline_state_notify=on_state,
      )
)

with sdk.create_audio_processor(attrs) as proc:
      ...
```

For full setup and initialization, see the [Quick Start →](/Docs/Getting-Started/Quick-Start)

## Next Steps

<CardGroup>
  <Card title="Quick Start" icon="rocket" href="/Docs/Getting-Started/Quick-Start">
    Get up and running with Sanas SDK in under 5 minutes.
  </Card>

  <Card title="API Reference" icon="book" href="/API-Reference/Overview">
    Full SDK documentation for classes, enums, and callbacks.
  </Card>

  <Card title="Processing Multiple Streams" icon="layer-group" href="/Docs/Tutorials/Processing-Multiple-Streams">
    Handle multiple concurrent audio streams.
  </Card>
</CardGroup>


# SE 1.2 - Enhanced 
Source: https://developer.sanas.ai/Docs/Models/Human-Human/se-1-2

Real-time full-fidelity speech enhancement — denoising, de-reverberation, speech reconstruction, and bandwidth extension to 24kHz.

The Speech Enhancement `SE1.2` model delivers full-fidelity speech enhancement for demanding Human ↔ Human audio. It takes input up to 16kHz and outputs ultra-fidelity 24kHz audio, going beyond noise removal to reconstruct and restore degraded speech, remove reverberation, and recover quality lost to low-bitrate codecs — for a richer, clearer, more natural listening experience. Speaker identity and accent are preserved, without the perceptible shift seen in some other Speech Enhancement models.

## Key Features

<CardGroup>
  <Card title="Bandwidth Extension" icon="arrow-up-right-dots">
    Extends audio to ultra-fidelity 24kHz for a richer, more natural voice experience beyond standard telephony quality.
  </Card>

  <Card title="Denoising" icon="volume-slash">
    Removes background noise and non-primary voices, including residual noise and background speech left by earlier models.
  </Card>

  <Card title="Speech Reconstruction" icon="microphone">
    Reconstructs and restores degraded speech, improving intelligibility and signal clarity — even without upsampling.
  </Card>

  <Card title="De-reverberation" icon="wrench">
    Removes room reverberation from the signal for a cleaner, more present voice.
  </Card>

  <Card title="Codec Restoration" icon="arrows-rotate">
    Recovers quality lost to low-bitrate codec compression.
  </Card>

  <Card title="Cleaner High Frequencies" icon="waveform-lines">
    Improved reproduction of sibilants and fricatives (reduced lisping) and reduced scratchiness in very low signal-to-noise conditions.
  </Card>
</CardGroup>

## Specifications

**Model ID:** `SE1.2`<br />**Category:** Speech Enhancement<br />**Type:** Human ↔ Human

<CardGroup>
  <Card title="40ms–90ms" icon="bolt">
    Streaming latency
  </Card>

  <Card title="16kHz → 24kHz" icon="waveform-lines">
    Input / Output sample rate
  </Card>
</CardGroup>

<Note>
  **Input constraint:** input bandwidth above 8kHz is not supported, so the maximum input sampling rate is 16kHz. The model operates and outputs at 24kHz.

  Latency: 40ms when running noise cancellation only; up to 90ms when using the full enhancement pipeline (bandwidth extension, de-reverberation, speech reconstruction, and codec restoration). CPU footprint is comparable to SE 1.0, with only a modest increase.
</Note>

## Use Cases

<CardGroup>
  <Card title="Contact Centers" icon="headset">
    Premium voice quality for agent-customer calls where clarity and presence matter most.
  </Card>

  <Card title="Conferencing" icon="users">
    Ultra-fidelity audio for video conferences and virtual meetings.
  </Card>

  <Card title="Telemedicine" icon="stethoscope">
    Crystal-clear audio for doctor-patient consultations where every word counts.
  </Card>

  <Card title="Degraded & Codec-Compressed Audio" icon="circle-dot">
    Restore intelligibility on noisy, reverberant, or low-bitrate codec-degraded audio.
  </Card>
</CardGroup>

<Note>
  **Known Limitations**

  * Some residual lisping can remain on speech with bandwidth below \~3kHz.
  * Some scratchiness and artifacts can remain on audio compressed with very low-bitrate codecs.
</Note>

## Code Example

Create an audio processor with the SE 1.2 model:

```python theme={null}
attrs = sanas.ProcessorAttributes(
      audio_attributes=sanas.AudioAttributes(
                sampling_rate=16000,
                channels=1,
                model_name="SE1.2",
                audio_pipeline_state_notify=on_state,
      )
)

with sdk.create_audio_processor(attrs) as proc:
      ...
```

For full setup and initialization, see the [Quick Start →](/Docs/Getting-Started/Quick-Start)

## Next Steps

<CardGroup>
  <Card title="Quick Start" icon="rocket" href="/Docs/Getting-Started/Quick-Start">
    Get up and running with Sanas SDK in under 5 minutes.
  </Card>

  <Card title="API Reference" icon="book" href="/API-Reference/Overview">
    Full SDK documentation for classes, enums, and callbacks.
  </Card>

  <Card title="Processing Multiple Streams" icon="layer-group" href="/Docs/Tutorials/Processing-Multiple-Streams">
    Handle multiple concurrent audio streams.
  </Card>
</CardGroup>


# Agentic SE Voice Isolation
Source: https://developer.sanas.ai/Docs/Models/Human-Machine/Agentic-SE-Voice-Isolation

ASR-optimized speech enhancement for voice AI pipelines

The Voice Isolation Agentic SE (`AGENTIC_VI_G_SE`) model is designed to improve Automatic Speech Recognition (ASR) accuracy in noisy environments. Unlike traditional speech enhancement optimized for human perception, this model preserves the acoustic and phonetic information that ASR systems depend on while removing conversational disruptions.

## Hear the Difference

Removes environmental background noise and distant human voices from the primary speaker's audio stream for complete voice isolation, ensuring ASR processes only the primary speaker's input.

<div>
  <div>
    **Before** · Primary speaker + background noise

    <video />
  </div>

  <div>
    **After** · Primary speaker only

    <video />
  </div>
</div>

### Performance Benchmarks

The following transcripts are generated from the audio samples above. The **Oracle Transcript** is the ground truth — the actual words spoken. The **Source Transcript** is the raw audio passed directly through the ASR system. The **Sanas Transcript** is the audio processed through the Sanas model first, then passed through the same ASR system. The **Word Error Rate (WER)** is calculated relative to the Oracle Transcript (0% WER), based on insertion, deletion, and substitution errors — bolded words below indicate these errors. WER percentage for each is shown at the bottom of the table.

#### Test Environment

* **Background**: Contact center with background office chatter and ambient noise
* **ASR System**: Deepgram Nova3 Streaming

| Oracle Transcript | Source Transcript | Sanas Transcript |
| - | - | - |
| good morning welcome to sun bank fraud prevention desk this is partha speaking how can i assist i completely understand let's check your account immediately uh for verification may i have the last four digits of your card thank you i will review your account i see an o t p multiple request attempted today but no transaction went through did anyone recently ask for your o t p or card details good please remember we will never ask for your o t p to keep your account safe i recommend blocking the card immediately and issuing a replacement would you like me to proceed done your card has been blocked successfully your replacement card will reach your uh reach your registered address in three to five business days okay yes i'm also enabling security alerts for your account you are welcome anything else i can help you with today | good morning welcome to sunbank fraud prevention desk this is speaking how can i assist i completely understand let's check your account immediately for okay to **continueusing** yes i'm also enabling security alerts for your account **will you write me the changes to you** you are welcome anything else i can help you with **changing your account** | good morning welcome to sunbank fraud prevention desk this is speaking how can i assist i completely understand let's check your account immediately for verification may i have the last four digits of your card thank you i will review your account i will see an o t p request attempted today but no transaction went through did anyone recently ask for your o t p or card details good **september** we will never ask for your o t p to keep your account safe i recommend blocking the card immediately and **issue** a replacement would you like me to proceed done your card has been blocked successfully your replacement card will reach your reach your registered address in three to five business days okay i'm also enabling security alerts for your account you are welcome anything else i can help you with today |


# Agentic SE Standard
Source: https://developer.sanas.ai/Docs/Models/Human-Machine/Agentic-Speech-Enhancement/Agentic-SE-Standard

ASR-optimized speech enhancement with speech preservation for multi-speaker environments

The Standard Agentic SE (`AGENTIC_ST_SE`) model is designed to improve Automatic Speech Recognition (ASR) accuracy in noisy multi-speaker environments. Unlike traditional speech enhancement optimized for human perception, this model preserves the acoustic and phonetic information that ASR systems depend on, including distant human speech, while removing environmental noise.

## Hear the Difference

Removes environmental background noise while preserving distant human speech, ensuring ASR captures every speaker in multi-speaker environments where background conversations carry context.

<div>
  <div>
    **Before** · Multiple speakers + background noise

    <video />
  </div>

  <div>
    **After** · All speakers preserved, noise removed

    <video />
  </div>
</div>

### Performance Benchmarks

The following transcripts are generated from the audio samples above. The **Oracle Transcript** is the ground truth — the actual words spoken. The **Source Transcript** is the raw audio passed directly through the ASR system. The **Sanas Transcript** is the audio processed through the Sanas model first, then passed through the same ASR system. The **Word Error Rate (WER)** is calculated relative to the Oracle Transcript (0% WER), based on insertion, deletion, and substitution errors — bolded words below indicate these errors. WER percentage for each is shown at the bottom of the table.

#### Test Environment

* **Background**: Indoor environment with TV audio playing at moderate volume
* **ASR System**: Deepgram Nova3 Streaming

| Oracle Transcript | Source Transcript | Sanas Transcript |
| - | - | - |
| hi my name is partho i'm here recording audio for snc dataset here i am uh playing the stock market news in moderate volume i'll give a pause for few seconds okay i will talk again for a few minutes then i will again give a pause so uh we would try to record in more different scenarios let's give a pause for another five seconds maybe okay uh they're showing advertisement now so i'm going to stop the recording here | hi my name is **barto** i'm here recording audio for s n c dataset here i am uh playing the stock market news in moderate volume i'll give a pause for a few seconds **wait for it till they're enter i think so not a taker right now in terms of like push move our goals but let's quickly slip into a topic** okay i will talk again for a few minutes then i will again give a pause so we would try to record in more different scenarios let's give a pause for another five seconds maybe okay they're showing advertisement now so i'm going to stop the recording here | hi my name is **barto** i'm here recording audio for s **m** c dataset here i am uh playing the stock market news in moderate volume i'll give a pause for few seconds okay i will talk again for a few minutes then i will again give a pause so we would try to record in more different scenarios let's give a pause for another five seconds maybe okay they're showing advertisement now so i'm going to stop the recording here |


# Agentic SE Voice Isolation (Telephony)
Source: https://developer.sanas.ai/Docs/Models/Human-Machine/Agentic-Speech-Enhancement/Agentic-SE-Voice-Isolation-Telephony

ASR-optimized speech enhancement for telephony audio pipelines

The Voice Isolation Telephony Agentic SE (`AGENTIC_VI_GT_SE`) model is a telephony-optimized variant of the [`AGENTIC_VI_G_SE`](/Docs/Models/Human-Machine/Agentic-SE-Voice-Isolation) model, purpose-built for 8kHz telephony audio. It improves Automatic Speech Recognition (ASR) accuracy by isolating the primary speaker and removing background noise and voices from narrowband telephony streams.

<Note>
  **Which model should you use?**

  * **16kHz input:** Use [`AGENTIC_VI_G_SE`](/Docs/Models/Human-Machine/Agentic-SE-Voice-Isolation) (General)
  * **8kHz input:** Use `AGENTIC_VI_GT_SE` (Telephony)
</Note>

## Hear the Difference

Removes environmental background noise and distant human voices from telephony audio for complete voice isolation, ensuring ASR processes only the primary speaker's input.

<div>
  <div>
    **Before** · Primary speaker + background noise

    <video />
  </div>

  <div>
    **After** · Primary speaker only

    <video />
  </div>
</div>

### Performance Benchmarks

The following transcripts are generated from the audio samples above. The **Oracle Transcript** is the ground truth — the actual words spoken. The **Source Transcript** is the raw audio passed directly through the ASR system. The **Sanas Transcript** is the audio processed through the Sanas model first, then passed through the same ASR system. The **Word Error Rate (WER)** is calculated relative to the Oracle Transcript (0% WER), based on insertion, deletion, and substitution errors — bolded words below indicate these errors. WER percentage for each is shown at the bottom of the table.

#### Test Environment

* **Background**: Contact center with background office chatter and ambient noise
* **ASR System**: Deepgram Nova3 Streaming

| Oracle Transcript | Source Transcript | Sanas Transcript |
| - | - | - |
| good morning welcome to sun bank fraud prevention desk this is partha speaking how can i assist i completely understand let's check your account immediately uh for verification may i have the last four digits of your card thank you i will review your account i see an o t p multiple request attempted today but no transaction went through did anyone recently ask for your o t p or card details good please remember we will never ask for your o t p to keep your account safe i recommend blocking the card immediately and issuing a replacement would you like me to proceed done your card has been blocked successfully your replacement card will reach your uh reach your registered address in three to five business days okay yes i'm also enabling security alerts for your account you are welcome anything else i can help you with today | good morning welcome to sunbank fraud prevention desk this is speaking how can i assist i completely understand let's check your account immediately for verification may i have the last four digits of your card thank you i will **remove the** account **i'll** see a **particular** request your replacement card will reach your reach your registered address three to five business days enabling security alerts for your account **will you write me the change this to you** you **were** welcome anything else i can help you with **changes to your account** | good morning welcome to sun bank fraud prevention desk this is **pasa** speaking how can i assist i completely understand **there's** check your account **in the details** for verification may i have the last **digits** of your card thank you i will **mhmm** your account attempted today **the new** transaction went through did anyone recently ask for **the otp of paralytus** good remember we will never ask for **the** o t p to keep your account safe i recommend blocking the card immediately and **issue you had a placement** would you like me to **give sir** your card has been blocked successfully your replacement card **has** reach**ed** your reach**ed** your registered address in three to **5%** i'm also enabling security **alert** for your account you are welcome anything else i can help you with **sir** |


# Agentic SE Overview
Source: https://developer.sanas.ai/Docs/Models/Human-Machine/Agentic-Speech-Enhancement/agentic-speech-enhancement-overview

Clean, isolate, and enhance audio before it reaches your ASR/STT engine — purpose-built for voice agents, IVR, and machine listeners.

# Agentic Speech Enhancement

> Cleaner audio in, more accurate transcripts out.

Sanas **Agentic Speech Enhancement (Agentic SE)** models prepare audio for machines rather than human listeners. They isolate the primary speaker, strip background noise and distant voices, and hand a clean signal to your speech-to-text (ASR/STT) engine — reducing recognition errors and making downstream voice-agent behavior more reliable.

All Agentic SE models are optimized for <span>Human ↔ Machine</span> experiences, where the "listener" is a transcription engine, IVR, or voice bot.

## Why Agentic SE

* **Lower word error rates** — cleaner input audio reduces Relative Word Error Rate (RWERR) for your ASR/STT.
* **Primary-speaker isolation** — removes distant voices and background noise so the agent hears one speaker.
* **Multi-speaker awareness** — a Standard variant preserves all human speech when background conversation carries context.
* **Telephony-ready** — a variant tuned for 8kHz narrowband phone audio.

## Core models

<CardGroup>
  <Card title="Agentic SE · Voice Isolation (General)" icon="robot" href="/Docs/Models/Human-Machine/Agentic-SE-Voice-Isolation">
    **`AGENTIC_VI_G_SE`** Removes background noise and distant voices for complete voice isolation of the primary speaker's audio stream.
  </Card>

  <Card title="Agentic SE · Voice Isolation (Telephony)" icon="robot" href="/Docs/Agentic-SE-Voice-Isolation-Telephony">
    **`AGENTIC_VI_GT_SE`** Telephony-optimized variant of Voice Isolation for 8kHz narrowband audio.
  </Card>

  <Card title="Agentic SE · Standard" icon="robot" href="/Docs/Agentic-SE-Standard">
    **`AGENTIC_ST_SE`** Removes background noise while preserving all human speech for multi-speaker environments.
  </Card>
</CardGroup>

## Model comparison

| Model | Description | Best For | Latency | Sample rate | RWERR (avg) |
| - | - | - | - | - | - |
| `AGENTIC_VI_G_SE`<br />Agentic SE — Voice Isolation (General) | Removes all background noise and non-primary voices for complete speaker isolation | Single-speaker isolation for voice agents, IVR, phone bots | \~100ms | 16kHz | 5–30% |
| `AGENTIC_VI_GT_SE`<br />Agentic SE — Voice Isolation (Telephony) | Telephony-optimized variant for 8kHz narrowband audio | Telephony voice agents, IVR, contact centers | \~100ms | 8kHz | 5–30% |
| `AGENTIC_ST_SE`<br />Agentic SE — Standard | Removes background noise while keeping all human speech audible | Multi-speaker environments where background conversations carry context | \~100ms | 16kHz | 5–30% |

## How to choose

* Pick **Voice Isolation — General (`AGENTIC_VI_G_SE`)** when you want a single, isolated speaker stream for a voice agent, IVR, or phone bot at 16kHz.
* Pick **Voice Isolation — Telephony (`AGENTIC_VI_GT_SE`)** for the same isolation on 8kHz narrowband telephony audio.
* Pick **Standard (`AGENTIC_ST_SE`)** for multi-speaker environments where you need background noise removed but *all* human speech preserved.

<Note>
  Agentic SE models are designed to run **before** your ASR/STT engine to improve transcription accuracy. For audio intended for human listeners, use the [Speech Enhancement](/Docs/Models/Overview) (Human ↔ Human) models instead.
</Note>


# Models Overview 
Source: https://developer.sanas.ai/Docs/Models/Overview



Explore Sanas's Human ↔ Human and Human ↔ Machine models and their capabilities.

Sanas delivers world-class AI models across two categories: Human ↔ Human and Human ↔ Machine. Sanas currently offers Noise Cancellation and Speech Enhancement capabilities. Accent Translation, Language Translation, and Speech Intelligence coming soon.

## Who is listening?

<CardGroup>
  <Card title="A person is listening" icon="users">
    You need a **Human ↔ Human** model. Voice quality and naturalness matter.
  </Card>

  <Card title="A machine is listening" icon="robot">
    You need a **Human ↔ Machine** model. Relative Word Error Rate (RWERR) reduction and ASR accuracy matter.
  </Card>
</CardGroup>

## Agentic Speech Enhancement Models

| Model | Use Case | Description | Best For: |
| - | - | - | - |
| AGENTIC\_VI\_G\_SE | Agentic — Voice Isolation (General) — Human ↔ Machine | Removes all background noise and non-primary voices for complete speaker isolation | Voice agents, IVR, and phone bots that need a single, noise-free speaker isolated from everything else on the line |
| AGENTIC\_VI\_GT\_SE | Agentic — Voice Isolation (Telephony) — Human ↔ Machine | Telephony-optimized variant of VI\_G for 8kHz narrowband audio | Telephony-based voice agents and IVR in contact centers running on narrowband (8kHz) call audio |
| AGENTIC\_ST\_SE | Agentic — Standard — Human ↔ Machine | Removes background noise while keeping all human speech audible | Multi-party calls or meeting/triage agents where overheard background speech still adds useful context |

## Speech Enhancement Models

| Model | Use Case | Description | Best For: |
| - | - | - | - |
| SE1.2 | SE Enhanced (Telco) — Human ↔ Human | Enhances voice quality for narrowband telephony audio and adds comfort noise; mainly intended for Telco use cases | Telco and carrier-grade voice applications needing lightweight enhancement with natural-sounding comfort noise |
| SE2.1 | SE Standard — Human ↔ Human | Restores and enhances voice quality for telephony audio, outputting 8kHz | High-volume contact centers and IVR systems needing lightweight, low-latency voice cleanup on telephony audio |
| SE2.2 | SE Full-Fidelity — Human ↔ Human | Full-Fidelity speech enhancement with bandwidth extension to 24kHz | Premium contact centers, conferencing, and telemedicine where full-fidelity audio quality is essential |
| VI\_G\_SE | Voice Isolation (General) — Human ↔ Human | Isolates intended speech by removing background noise and voices | Contact center agents, conferencing, and live/gaming voice chat where listeners need clean, isolated speech |

## Accent Translation Models

| Model | Use Case | Description | Best For: |
| - | - | - | - |
| AT5.2 | Accent Translation — Human ↔ Human | Accent Translation modifies global accents in real-time, allowing your teams to be instantly understood while preserving what makes every voice unique. | Contact centers and global teams who need instant, natural-sounding accent translation in meetings and daily calls |

## Language Translation

| API | Use Case | Description | Best For: |
| - | - | - | - |
| [LT](/Docs/Language-Translation/Overview) | Language Translation— Human ↔ Human | Real-time language translation that preserves your speakers' voices, tone, and intent. | Cross-language customer support and international meetings that need real-time translation while preserving the speaker's voice and tone |

Hear samples and learn more about each model's specifications, use cases, and code examples below.

## Human ↔ Human

### Speech Enhancement · Enhanced (Telco)

**SE1.2** — Enhances voice quality for narrowband telephony audio and adds comfort noise. Mainly intended for Telco use cases.

### Speech Enhancement · Standard

**SE2.1** — Restores and enhances voice quality for telephony audio. Low CPU footprint.

* Latency: 120ms
* Sample rate: 16kHz → 8kHz

### Speech Enhancement · with full-fidelity

**SE2.2** — Full-fidelity speech enhancement with bandwidth extension to ultra-fidelity 24kHz.

* Latency: 160ms
* Sample rate: 16kHz → 24kHz

### Speech Enhancement · Voice Isolation (General)

**VI\_G\_SE** — Isolates intended speech by removing background noise and voices. Optimized for human listeners.

* Latency: \~40ms
* Sample rate: Up to 24kHz
* Range: Primary speaker within \~1m

### Accent Translation

**AT5.2** — Accent Translation modifies global accents in real-time, allowing your teams to be instantly understood while preserving what makes every voice unique.

* Latency: \~200ms

### Language Translation

[**LT**](/Docs/Language-Translation/Overview) — Real-time language translation that preserves your speakers' voices, tone, and intent.

* Latency: \~3-5s

## Human ↔ Machine

### Agentic Speech Enhancement · Voice Isolation (General)

**AGENTIC\_VI\_G\_SE** — Removes background noise and distant voices for complete voice isolation of the primary speaker's audio stream.

* Latency: \~100ms
* Sample rate: 16kHz
* Relative Word Error Rate Reduction (RWERR): 5–30% (average)

### Agentic Speech Enhancement · Voice Isolation (Telephony)

**AGENTIC\_VI\_GT\_SE**— Telephony-optimized variant of Voice Isolation for 8kHz narrowband audio.

* Latency: \~100ms
* Sample rate: 8kHz
* Relative Word Error Rate Reduction (RWERR): 5–30% (average)

### Agentic Speech Enhancement · Standard

**AGENTIC\_ST\_SE** — Removes background noise while preserving all human speech for multi-speaker environments.

* Latency: \~100ms
* Sample rate: 16kHz
* Relative Word Error Rate Reduction (RWERR): 5–30% (average)


# Sanas Developer Platform — FAQ  
Source: https://developer.sanas.ai/Docs/Resources/FAQ



Quick answers with links to the full docs. For end-user and admin help, see the [Help Center](https://help.sanas.ai/).

***

## Contents

1. [Getting Started & Access](#getting-started-&-access)
2. [Models & Capabilities](#models-&-capabilities)
3. [SDK, Integration & Development](#sdk-integration-&-development)
4. [Deployment & Infrastructure](#deployment-&-infrastructure)
5. [Performance, Scaling & Latency](#performance-scaling-&-latency)
6. [Security, Privacy & Compliance](#security-privacy-&-compliance)
7. [Pricing & Billing](#pricing-&-billing)
8. [Support & Troubleshooting](#support-&-troubleshooting)
9. [Roadmap](#roadmap)
10. [Still need help?](#still-need-help)

***

## Getting Started & Access

**What is the Sanas Developer Platform?** A suite of real-time speech AI models delivered through a single SDK that streams audio to Sanas Models via SIP/RTP (cloud inference today; local inference coming soon). See [Overview](https://developer.sanas.ai/Docs/Getting-Started/Overview).

**Need a developer account ?** [https://www.sanas.ai/developer-platform](https://www.sanas.ai/developer-platform)

**Who is it for?** Developers building voice agents, contact center audio, conferencing/gaming, and STT pipelines. See [Overview](https://developer.sanas.ai/Docs/Getting-Started/Overview).

**What are the system requirements?** Python 3.10–3.14 on Linux x86\_64, macOS (Apple Silicon arm64), or Windows. See [Quick Start](https://developer.sanas.ai/Docs/Getting-Started/Quick-Start).

**How fast can I get running?** Under five minutes with credentials in hand — follow the [Quick Start](https://developer.sanas.ai/Docs/Getting-Started/Quick-Start).

***

## Models & Capabilities

**What models are available today?** Speech Enhancement, Accent Translation, Language Translation, and Agentic Speech Enhancement. Full list in [Models Overview](https://developer.sanas.ai/Docs/Models/Overview).

**Human ↔ Human vs. Human ↔ Machine?** Human ↔ Human is tuned for a human listener; Human ↔ Machine ("Agentic") is tuned to feed an ASR/voice-agent pipeline. See [Choose Your Model](https://developer.sanas.ai/Docs/Models/Choose-Your-Model).

**How do I pick the right model?** Use the decision guide in [Choose Your Model](https://developer.sanas.ai/Docs/Models/Choose-Your-Model).

**What is Agentic Speech Enhancement?** Voice isolation applied before ASR/STT to reduce word error rate. See [Agentic Speech Enhancement models](https://developer.sanas.ai/Docs/Models/Overview).

**Are Accent and Language Translation in the SDK?** Yes. See [Overview](https://developer.sanas.ai/Docs/Getting-Started/Overview).

***

## SDK, Integration & Development

**What platforms are supported?** Python 3.10–3.14 on Linux x86\_64, macOS (Apple Silicon arm64), and Windows, as of SDK v2.0.1.

**How does authentication work?** Credential-based via `InitParams` — full code sample in [Authentication](https://developer.sanas.ai/Docs/Getting-Started/Authentication).

**How should I store my API Key?** In environment variables; never commit it or expose it in code, and rotate if compromised. See [Authentication](https://developer.sanas.ai/Docs/Getting-Started/Authentication).

**What's the integration flow?** Initialize → create processor → process samples → destroy → shutdown. Step-by-step in [Quick Start](https://developer.sanas.ai/Docs/Getting-Started/Quick-Start).

**How do I process multiple concurrent streams?** Reuse one SDK instance with a processor per stream — see [Processing Multiple Streams](https://developer.sanas.ai/Docs/Tutorials/Processing-Multiple-Streams).

**Is there an API reference?** Yes — [API Reference](https://developer.sanas.ai/API-Reference/Overview) and [OpenAPI spec](https://developer.sanas.ai/api-reference/openapi.json).

***

## Deployment & Infrastructure

**What deployment options exist?** [Sanas Cloud](https://developer.sanas.ai/Docs/Deployment/Sanas-Cloud) (available now) and [Self-Hosted](https://developer.sanas.ai/Docs/Deployment/Self-Hosted) (coming soon).

**Which regions are available?** US (Ohio) and South Asia (Mumbai), more coming. See [Sanas Cloud](https://developer.sanas.ai/Docs/Deployment/Sanas-Cloud).

**What network config do I need?** Allow SIP and RTP traffic — see [Sanas Cloud](https://developer.sanas.ai/Docs/Deployment/Sanas-Cloud).

***

## Performance, Scaling & Latency

**What latency should I expect?** \~40 ms for noise cancellation, imperceptible to end users. See [Overview](https://developer.sanas.ai/Docs/Getting-Started/Overview).

**How many concurrent streams?** Hundreds, scaling automatically on Sanas Cloud. See [Sanas Cloud](https://developer.sanas.ai/Docs/Deployment/Sanas-Cloud).

**Does processing degrade audio?** No — isolation removes noise without quality loss, and enhancement restores it. See [Models Overview](https://developer.sanas.ai/Docs/Models/Overview).

***

## Security, Privacy & Compliance

**Is audio stored?** No — processed in real time, never stored on Sanas Cloud. See [Compliance & Data Residency](https://developer.sanas.ai/Docs/Enterprise/Compliance-and-Data-Residency).

**Is audio encrypted?** Yes — set `secureMedia = True`; TLS in transit, AES-256 at rest. See [Security](https://developer.sanas.ai/Docs/Enterprise/Security).

**What certifications does Sanas hold?** ISO 27001, SOC 2 Type II, HIPAA, GDPR, PCI DSS, CCPA. See [Compliance & Data Residency](https://developer.sanas.ai/Docs/Enterprise/Compliance-and-Data-Residency).

**Where is my data processed, and who are the sub-processors?** Full residency and sub-processor tables in [Compliance & Data Residency](https://developer.sanas.ai/Docs/Enterprise/Compliance-and-Data-Residency).

**Data retention and data-subject rights?** Retention windows and how to exercise your rights ([privacy@sanas.ai](mailto:privacy@sanas.ai)) are in [Compliance & Data Residency](https://developer.sanas.ai/Docs/Enterprise/Compliance-and-Data-Residency).

**Where's the DPA and full security posture?** [Trust Center](https://trust.sanas.ai), [DPA](https://www.sanas.ai/data-processing-agreement), [Privacy Policy](https://www.sanas.ai/privacy-policy).

***

## Pricing & Billing

**How does pricing work?** Usage-based. See [Pricing](https://developer.sanas.ai/Docs/Resources/Pricing).

**How do I get a quote?** Contact the [support portal](https://support.sanas.ai/support/home) or [support@sanas.ai](mailto:support@sanas.ai).

***

## Support & Troubleshooting

**How do I contact support?** [support@sanas.ai](mailto:support@sanas.ai) (1 business day) or the [Support Portal](https://support.sanas.ai) for urgent issues. See [Support](https://developer.sanas.ai/Docs/Enterprise/Support).

**Why did SDK initialization fail?** Usually a credential, endpoint, or SIP/RTP firewall issue — verify against [Authentication](https://developer.sanas.ai/Docs/Getting-Started/Authentication).

**Where do end users get help?** The [Help Center](https://help.sanas.ai/) covers desktop app, Portal, SSO, and softphone setup.

***

## Roadmap

**What's coming soon?** Speech Intelligence via SDK; self-hosted deployment; Windows support; more regions. Track releases in the [Changelog](https://developer.sanas.ai/Docs/Resources/Changelog).

***

## Still need help?

[support@sanas.ai](mailto:support@sanas.ai) · [Support Portal](https://support.sanas.ai) · [Docs](https://developer.sanas.ai/Docs/Getting-Started/Overview) · [Trust Center](https://trust.sanas.ai)


# Pricing
Source: https://developer.sanas.ai/Docs/Resources/Pricing



Please [contact our support team](https://support.sanas.ai/support/home) or email [platform-sales@sanas.ai](mailto:platform-sales@sanas.ai) for Sanas SDK usage pricing.

## Model Pricing

| Model | Inference Location | Price per Minute |
| - | - | - |
| Agentic Speech Enhancement<br />`AGENTIC_ST_SE,  AGENTIC_VI_GT_SE,  AGENTIC_VI_G_SE` | Sanas Cloud | \$0.0043 |
| Speech Enhancement<br />`VI_G_SE (SE1.0), SE 1.2, SE2.1, SE2.2` | Sanas Cloud | \$0.0040 |
| Accent Translation  <br />`AT5.2` | Sanas Cloud | \$0.0090 |
| Language Translation | Sanas Cloud | \$0.0900 |

*If you are interested in volume discounts please — [contact sales](mailto:platform-sales@sanas.ai).*


# Tutorial: Language Translation
Source: https://developer.sanas.ai/Docs/Tutorials/Language-Translation

Translate speech from one language to another and receive both translated audio and transcript segments.

Language Translation (LT) runs on the remote-inference pipeline. Unlike audio processing, it is **selected by the presence of an `lt_config`**, not by a model key — so `AudioAttributes.model_name` is left empty. Translated audio comes back from `process_frame`; transcripts arrive on the `lt_config` callback.

This tutorial follows the `language_translation_example.py` example. If you haven't yet, read [Processing a Single Stream](/Docs/Tutorials/Single-Stream) first — LT reuses the same activation, pipeline-readiness, and real-time feed mechanics.

<Warning>
  LT has a large round-trip latency (\~3–4 s). You must keep pushing silence for a window that **exceeds** that latency after the input ends, or the translated tail will be lost.
</Warning>

## Prerequisites

Only `SANAS_API_KEY` is required. Everything else — language codes, conversation ID, and the silence drain window — is optional and can be set directly in code via `LanguageTranslationConfig` when you don't want the defaults.

```bash theme={null}
export SANAS_API_KEY="your-key"
python language_translation_example.py --input test_input.wav --output translated.wav
```

## Step 1: Handle transcript callbacks

Transcripts arrive as `TextFrame`s. Each frame is either a `TRANSLATION` or a `TRANSCRIPTION`, carries an utterance index and language code, and contains `complete` and `partial` segments. Segments may include redacted text.

```python theme={null}
import sanas

def print_transcript(tf):
    label = "Translation" if tf.type_ == sanas.TranscriptType.TRANSLATION else "Transcription"
    td = tf.transcript_data_
    lang = f" lang={td.language_code_}" if td.language_code_ else ""
    print(f"\n[{label}] utterance {td.utterance_idx}{lang}")
    for kind, segs in (("complete", td.complete), ("partial", td.partial)):
        for s in segs:
            redacted = f' (redacted: "{s.redacted_text}")' if s.redacted_text else ""
            print(f'  [{kind}] "{s.text}"{redacted} [{s.start}-{s.end} p={s.probability:.2f}]')
```

## Step 2: Activate and load audio

Identical to single-stream processing:

```python theme={null}
from helpers import PipelineWaiter, feed_and_drain, load_samples
from wav_utils import save_wav

sdk = sanas.create_sdk(sanas.InitParams(storage_dir=storage_dir))
res = sdk.activate_api_key(api_key)
if not res.success:
    sys.exit(f"Activation failed: {res.message}")
print(f"[activation] OK (SDK {sdk.version})")

samples, sample_rate, channels = load_samples(args.input)
```

## Step 3: Configure translation via `lt_config`

Leave `model_name` empty and attach a `LanguageTranslationConfig`. Its presence is what puts the pipeline into translation mode.

```python theme={null}
waiter = PipelineWaiter(on_state=lambda s: print(f"[pipeline] {s}"))

attrs = sanas.ProcessorAttributes(
    audio_attributes=sanas.AudioAttributes(
        sampling_rate=sample_rate,
        channels=channels,
        model_name="",   # LT is selected by lt_config, not a model key
        audio_pipeline_state_notify=waiter.callback,
    ),
    lt_config=sanas.LanguageTranslationConfig(
        language_in=lang_in,
        language_out=lang_out,
        conversation_id=conversation_id,   # optional; links two-party sessions
        callback=print_transcript,
    ),
)
```

## Step 4: Feed with an extended drain window

Because translation lags several seconds behind the input, pass `drain_seconds` to `feed_and_drain`. This makes the helper pump silence for a fixed, real-time-paced window (instead of stopping early on empty frames), giving the remote wall-clock time to return the tail.

```python theme={null}
drain_seconds = float(os.environ.get("SANAS_LT_DRAIN_SECONDS", "5.0"))

with sdk.create_audio_processor(attrs) as proc:
    print("[pipeline] waiting for RUNNING ...")
    waiter.wait_until_running(timeout=30.0)
    result = feed_and_drain(proc, samples, sample_rate, channels, drain_seconds=drain_seconds)
```

<Note>
  Set `SANAS_LT_DRAIN_SECONDS` comfortably above the observed round-trip latency. The default of 5 s covers the typical \~3–4 s; increase it if your target language or network is slower.
</Note>

## Step 5: Save the translated audio

```python theme={null}
combined = result["output"]
if combined:
    save_wav(args.output, combined, sample_rate, channels)
    print(f"\n[output] {len(combined) // 4} samples -> {args.output}")
else:
    print("\n[output] no translated audio received.")
```

## How it differs from audio processing

| | Audio processing | Language Translation |
| - | - | - |
| Selected by | `model_name` (e.g. `VI_G_SE`) | presence of `lt_config` |
| `model_name` | a model key | empty string |
| Latency | \~50–100 ms | \~3–4 s |
| Tail drain | stop on empty frames (default) | fixed `drain_seconds` window |
| Extra output | processed audio only | audio **and** transcript callbacks |

## Next Steps

<CardGroup>
  <Card title="Processing a Single Stream" icon="waveform-lines" href="/Docs/Tutorials/Single-Stream">
    The core flow this benchmark scales up.
  </Card>

  <Card title="API Reference" icon="book" href="/API-Reference/Overview">
    Full SDK documentation for classes, enums, and callbacks.
  </Card>
</CardGroup>

## Next Steps

<CardGroup>
  <Card title="Language Translation" icon="language" href="/Docs/Tutorials/Language-Translation">
    Translate speech between languages and receive audio plus transcripts.
  </Card>

  <Card title="Processing Multiple Streams" icon="layer-group" href="/Docs/Tutorials/Processing-Multiple-Streams">
    Run many concurrent processors on one SDK instance.
  </Card>
</CardGroup>

## References

<CardGroup>
  <Card title="SDK" icon="server" href="/API-Reference/Reference/Core-Classes/RemoteSDK">
    SDK lifecycle methods including create\_sdk, activate\_api\_key, and create\_audio\_processor.
  </Card>

  <Card title="AudioProcessor" icon="waveform-lines" href="/API-Reference/Reference/Core-Classes/AudioProcessor">
    process\_frame method for audio processing.
  </Card>
</CardGroup>

***

## Need Help?

<CardGroup>
  <Card title="Email Support" icon="envelope" href="mailto:support@sanas.ai">
    [support@sanas.ai](mailto:support@sanas.ai)

    Response time: 1 business day
  </Card>

  <Card title="Support Portal" icon="ticket" href="https://support.sanas.ai">
    Raise a [support ticket](https://help.sanas.ai/) for urgent issues
  </Card>
</CardGroup>


# Processing Multiple Streams
Source: https://developer.sanas.ai/Docs/Tutorials/Processing-Multiple-Streams

Run many concurrent audio processors on a single SDK instance, and benchmark throughput, concurrency, and memory.

A single SDK instance can drive many audio processors at once. Because `process_frame` releases the GIL, streams running in separate threads process **in parallel**. This tutorial follows `multi_stream_example.py`, a benchmark that creates one SDK, runs N processors concurrently (one per thread), and reports success/failure counts, peak concurrency, per-stream wall time, and optional memory growth.

<Note>
  Reuse one `Sdk` object across all streams — you activate once, then create a processor per thread. Do not create an SDK per stream.
</Note>

## Prerequisites

| Variable | Required | Default | Purpose |
| - | - | - | - |
| `SANAS_API_KEY` | Yes | — | Licence key |
| `SANAS_STORAGE_DIR` | No | `./storage` | SDK data + logs |

```bash theme={null}
export SANAS_API_KEY="your-key"

python multi_stream_example.py --streams 8 --concurrency 4 --rate 2 \
    --model VI_G_SE --input test_input.wav
```

### Command-line flags

| Flag | Default | Meaning |
| - | - | - |
| `--streams` | `4` | Total number of streams to run |
| `--concurrency` | `= --streams` | Max streams running at once |
| `--rate` | `0` | Stream start rate per second (0 = all at once) |
| `--model` | `VI_G_SE` | Model key |
| `--input` | `test_input.wav` | Input WAV path |
| `--max-throughput` | off | Feed as fast as possible instead of real-time pacing |
| `--pcm16` | off | Negotiate raw 16-bit PCM (cloud inference only) |
| `--save-wav-out-period N` | `0` | Save every Nth stream's output for spot-checking |

<Tip>
  Install `psutil` (`pip install psutil`) to also report process memory growth — useful for spotting leaks in long soak runs. The benchmark runs fine without it; the memory lines are simply omitted.
</Tip>

## Step 1: Create and activate one SDK

```python theme={null}
import sanas

sdk = sanas.create_sdk(
    sanas.InitParams(storage_dir=os.environ.get("SANAS_STORAGE_DIR", "./storage"))
)
res = sdk.activate_api_key(os.environ["SANAS_API_KEY"])
if not res.success:
    sys.exit(f"Activation failed: {res.message}")
print(f"[activation] OK (SDK {sdk.version})")

samples, sample_rate, channels = load_samples(args.input)
```

## Step 2: Define a per-stream worker

Each stream builds its own `PipelineWaiter`, processor, and cloud params, then feeds the shared samples. Exceptions are caught per stream so one failure doesn't take down the others. Note `collect_output` is only turned on when you actually intend to save audio — leaving it off keeps the memory-growth metric honest.

```python theme={null}
def _run_stream(sdk, idx, samples, sample_rate, channels, model,
                realtime, use_pcm16, save_period, stats):
    result = {"idx": idx, "ok": False, "error": None, "wall_s": 0.0, "saved": None}
    stats.stream_started()
    t0 = time.monotonic()
    try:
        cloud_params = sanas.CloudInferencingParams()
        cloud_params.use_pcm16 = use_pcm16
        waiter = PipelineWaiter()
        attrs = sanas.ProcessorAttributes(
            audio_attributes=sanas.AudioAttributes(
                sampling_rate=sample_rate,
                channels=channels,
                model_name=model,
                cloud_inferencing_params=cloud_params,
                audio_pipeline_state_notify=waiter.callback,
            )
        )
        with sdk.create_audio_processor(attrs) as proc:
            waiter.wait_until_running(timeout=30.0)
            drained = feed_and_drain(
                proc, samples, sample_rate, channels,
                realtime=realtime, collect_output=save_period > 0,
            )
        result["wall_s"] = time.monotonic() - t0
        if save_period and idx % save_period == 0 and drained["output"]:
            out_path = f"stream_{idx}.wav"
            save_wav(out_path, drained["output"], sample_rate, channels)
            result["saved"] = out_path
        result["ok"] = True
    except Exception as e:   # report per-stream, keep others going
        result["error"] = f"{type(e).__name__}: {e}"
        result["wall_s"] = time.monotonic() - t0
    finally:
        stats.stream_finished(result["ok"])
    return result
```

## Step 3: Track live statistics

`LiveStats` is a thread-safe counter aggregated across streams. Its `active` and `peak_concurrent` fields reveal how many streams actually overlapped — something per-stream result dicts can't show on their own.

```python theme={null}
class LiveStats:
    def __init__(self):
        self._lock = threading.Lock()
        self.started = self.completed = self.failed = self.active = 0
        self.peak_concurrent = 0
        self.start_time = time.monotonic()

    def stream_started(self):
        with self._lock:
            self.started += 1
            self.active += 1
            self.peak_concurrent = max(self.peak_concurrent, self.active)

    def stream_finished(self, ok):
        with self._lock:
            self.active -= 1
            if ok:
                self.completed += 1
            else:
                self.failed += 1
```

A background `MemorySampler` thread records peak RSS every 0.5 s (a no-op without `psutil`). Sampling — rather than reading once at the end — captures the true high-water mark while streams overlap, so a leak or transient spike shows up in the report.

## Step 4: Launch streams on a thread pool

Use a `ThreadPoolExecutor` sized to `--concurrency`. Optionally stagger starts with `--rate` to model a ramp-up instead of a thundering herd.

```python theme={null}
from concurrent.futures import ThreadPoolExecutor, as_completed

with ThreadPoolExecutor(max_workers=concurrency) as pool:
    futures = []
    for i in range(args.streams):
        futures.append(pool.submit(
            _run_stream, sdk, i, samples, sample_rate, channels,
            args.model, realtime, args.pcm16, args.save_wav_out_period, stats,
        ))
        if args.rate > 0 and i + 1 < args.streams:
            time.sleep(1.0 / args.rate)   # stagger stream starts
    for fut in as_completed(futures):
        r = fut.result()
        tag = "ok" if r["ok"] else f"FAILED ({r['error']})"
        print(f"[stream {r['idx']}] {tag}  wall={r['wall_s']:.2f}s")
```

## Step 5: Read the report

```text theme={null}
============================================================
Benchmark summary
============================================================
streams        : 8  (ok=8, failed=0)
success rate   : 100.0%
peak concurrent: 4
uptime         : 12.34s
memory (RSS)   : start=95.2 MB  peak=180.6 MB  growth=+85.4 MB
```

Interpreting it: **success rate** flags whether the configured concurrency is sustainable; **peak concurrent** confirms streams actually overlapped up to your `--concurrency` limit; **memory growth** should stay flat across a long soak run — steady climbing suggests a leak.

## Tuning tips

Use `--max-throughput` to measure how fast the pipeline *can* process (no real-time pacing) versus the default real-time feed that models a live call. Raise `--concurrency` gradually and watch the success rate and memory growth to find a safe ceiling for your hardware and model. Leave `--save-wav-out-period` at `0` for benchmarking; set it to spot-check output quality on a sample of streams.

## Next Steps

<CardGroup>
  <Card title="Processing a Single Stream" icon="waveform-lines" href="/Docs/Tutorials/Single-Stream">
    The core flow this benchmark scales up.
  </Card>

  <Card title="API Reference" icon="book" href="/API-Reference/Overview">
    Full SDK documentation for classes, enums, and callbacks.
  </Card>
</CardGroup>

## Next Steps

<CardGroup>
  <Card title="Language Translation" icon="language" href="/Docs/Tutorials/Language-Translation">
    Translate speech between languages and receive audio plus transcripts.
  </Card>

  <Card title="Processing Multiple Streams" icon="layer-group" href="/Docs/Tutorials/Processing-Multiple-Streams">
    Run many concurrent processors on one SDK instance.
  </Card>
</CardGroup>

## References

<CardGroup>
  <Card title="SDK" icon="server" href="/API-Reference/Reference/Core-Classes/RemoteSDK">
    SDK lifecycle methods including create\_sdk, activate\_api\_key, and create\_audio\_processor.
  </Card>

  <Card title="AudioProcessor" icon="waveform-lines" href="/API-Reference/Reference/Core-Classes/AudioProcessor">
    process\_frame method for audio processing.
  </Card>
</CardGroup>

***

## Need Help?

<CardGroup>
  <Card title="Email Support" icon="envelope" href="mailto:support@sanas.ai">
    [support@sanas.ai](mailto:support@sanas.ai)

    Response time: 1 business day
  </Card>

  <Card title="Support Portal" icon="ticket" href="https://support.sanas.ai">
    Raise a [support ticket](https://help.sanas.ai/) for urgent issues
  </Card>
</CardGroup>


# Processing a Single Stream
Source: https://developer.sanas.ai/Docs/Tutorials/Single-Stream

Run a WAV file through the Sanas SDK end to end — activate, wait for RUNNING, feed 20 ms frames, and drain the tail.

This tutorial walks through the core Sanas SDK flow using the `sdk_example.py` example. You'll read a WAV file, run it through a model, and write the processed audio back out. Along the way you'll use two shared helper modules — `wav_utils.py` (stdlib-only WAV I/O) and `helpers.py` (pipeline readiness and real-time pacing) — which every example depends on.

<Note>
  The SDK works with **interleaved float32 PCM** in `[-1, 1]`. You bring your own audio; the SDK never opens a microphone or speaker for you.
</Note>

## The core flow

Every audio-processing session follows the same five steps:

1. `create_sdk` → `activate_api_key` (synchronous, returns an `SdkResult`)
2. `create_audio_processor` with an `audio_pipeline_state_notify` callback
3. Wait for `PipelineState.RUNNING` before feeding frames
4. Feed 20 ms frames at real time, then drain the buffered tail with silence
5. Save the processed audio

<Tip>
  `process_frame` is synchronous and returns the processed frame directly. The model buffers \~50–100 ms internally, so the output lags the input. After the real audio is exhausted you push silence to pull the buffered tail back out.
</Tip>

## Prerequisites

Set your credentials and pick an input file via environment variables and CLI flags:

| Variable | Required | Default | Purpose |
| - | - | - | - |
| `SANAS_API_KEY` | Yes | — | Licence key |
| `SANAS_STORAGE_DIR` | No | `./storage` | SDK data + logs (created if missing) |

```bash theme={null}
export SANAS_API_KEY="your-key"
export SANAS_STORAGE_DIR=./storage

python sdk_example.py --model VI_G_SE --input test_input.wav --output output.wav
```

Command-line flags: `--model` (model key, default `VI_G_SE`), `--input`, `--output`, and `--pcm16` (opt into raw 16-bit PCM uplink — cloud inference only).

## Step 1: Create and activate the SDK

Activation is inline and blocking. Always check the returned `SdkResult` before continuing.

```python theme={null}
import sanas

sdk = sanas.create_sdk(sanas.InitParams(storage_dir=storage_dir))
res = sdk.activate_api_key(api_key)   # blocks, returns SdkResult
if not res.success:
    sys.exit(f"Activation failed: {res.message}")
print(f"[activation] OK (SDK {sdk.version})")
```

## Step 2: Load the input audio

`load_samples` (from `helpers.py`) wraps `read_wav` and returns the audio as an `array('f')` ready to slice into `AudioFrame`s.

```python theme={null}
from helpers import load_samples

samples, sample_rate, channels = load_samples(args.input)
print(f"[input] {sample_rate} Hz, {channels} ch, {len(samples) // channels} frames")
```

Under the hood, `wav_utils.read_wav` parses the WAV header directly (Python's `wave` module only handles PCM) so it accepts both **16-bit PCM** and **32-bit IEEE float** input, including `WAVE_FORMAT_EXTENSIBLE`. It returns interleaved little-endian float32 regardless of host endianness.

## Step 3: Build the processor with a state callback

The pipeline initializes asynchronously, so you must wait for `PipelineState.RUNNING` before feeding frames. `PipelineWaiter` (from `helpers.py`) bridges the `audio_pipeline_state_notify` callback to a waitable value.

```python theme={null}
from helpers import PipelineWaiter

waiter = PipelineWaiter(on_state=lambda s: print(f"[pipeline] {s}"))

cloud_params = sanas.CloudInferencingParams()
cloud_params.use_pcm16 = args.pcm16

attrs = sanas.ProcessorAttributes(
    audio_attributes=sanas.AudioAttributes(
        sampling_rate=sample_rate,
        channels=channels,
        model_name=args.model,
        cloud_inferencing_params=cloud_params,
        audio_pipeline_state_notify=waiter.callback,
    )
)
```

<Accordion title="Why a Condition instead of a plain Event?" icon="circle-question">
  A `threading.Event` only signals "something happened" and carries no value. `PipelineWaiter` uses a `threading.Condition` that notifies on **every** state change while keeping the latest state in `last_state`. Waiters wake on any transition and then inspect the value to decide whether to proceed (`RUNNING`), fail (`NOT_RUNNING`), or keep waiting. The state callback fires on a background thread, so publishing under a lock is required.
</Accordion>

## Step 4: Feed frames and drain the tail

Open the processor, wait for `RUNNING`, then hand off to `feed_and_drain`.

```python theme={null}
with sdk.create_audio_processor(attrs) as proc:
    print("[pipeline] waiting for RUNNING ...")
    waiter.wait_until_running(timeout=30.0)

    def _progress(pushed, total):
        pct = 100.0 * pushed / total if total else 100.0
        print(f"\r[feed] {pct:5.1f}%", end="", flush=True)

    result = feed_and_drain(proc, samples, sample_rate, channels, progress=_progress)
    print()
```

`feed_and_drain` splits the audio into fixed 20 ms chunks and calls `process_frame` on each. When `realtime=True` (the default), it paces the feed against a fixed monotonic schedule so timing self-corrects and doesn't drift:

```python theme={null}
next_deadline += chunk_seconds
sleep_until(next_deadline)
```

The final short chunk is padded with silence so no audio is dropped. After the input is exhausted, the helper drains the buffered tail. For low-latency models (NC/SE) it stops once the pipeline goes quiet (three consecutive empty frames); for high-latency pipelines you pass `drain_seconds` to pump silence for a fixed window instead.

<Tip>
  `sleep_until` sleeps until \~1 ms before the deadline, then busy-waits the last millisecond for tighter pacing than a bare `time.sleep()`.
</Tip>

## Step 5: Save the output

```python theme={null}
from wav_utils import save_wav

combined = result["output"]
if combined:
    save_wav(args.output, combined, sample_rate, channels)
    print(f"[output] {len(combined) // 4} samples -> {args.output}")
else:
    print("[output] no processed frames received.")
```

`save_wav` clamps each sample to `[-1, 1]` and writes a 16-bit PCM WAV.

## Full example

```python theme={null}
import argparse
import os
import sys

_HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, _HERE)

import sanas
from helpers import PipelineWaiter, feed_and_drain, load_samples
from wav_utils import save_wav


def _run():
    parser = argparse.ArgumentParser(
        description="Process a WAV file through the Sanas SDK (single stream)."
    )
    parser.add_argument("--model", default="VI_G_SE", help="ml model key")
    parser.add_argument("--input", default="test_input.wav", help="input WAV path")
    parser.add_argument("--output", default="output.wav", help="output WAV path")
    parser.add_argument(
        "--pcm16",
        action="store_true",
        help="negotiate L16 (raw 16-bit PCM); cloud inference only",
    )
    args = parser.parse_args()

    api_key = os.environ.get("SANAS_API_KEY")
    if not api_key:
        sys.exit("SANAS_API_KEY is not set.")
    storage_dir = os.environ.get("SANAS_STORAGE_DIR", "./storage")

    sdk = sanas.create_sdk(sanas.InitParams(storage_dir=storage_dir))
    res = sdk.activate_api_key(api_key)
    if not res.success:
        sys.exit(f"Activation failed: {res.message}")
    print(f"[activation] OK (SDK {sdk.version})")

    samples, sample_rate, channels = load_samples(args.input)
    print(f"[input] {sample_rate} Hz, {channels} ch, {len(samples) // channels} frames")

    waiter = PipelineWaiter(on_state=lambda s: print(f"[pipeline] {s}"))
    cloud_params = sanas.CloudInferencingParams()
    cloud_params.use_pcm16 = args.pcm16
    attrs = sanas.ProcessorAttributes(
        audio_attributes=sanas.AudioAttributes(
            sampling_rate=sample_rate,
            channels=channels,
            model_name=args.model,
            cloud_inferencing_params=cloud_params,
            audio_pipeline_state_notify=waiter.callback,
        )
    )

    with sdk.create_audio_processor(attrs) as proc:
        print("[pipeline] waiting for RUNNING ...")
        waiter.wait_until_running(timeout=30.0)

        def _progress(pushed, total):
            pct = 100.0 * pushed / total if total else 100.0
            print(f"\r[feed] {pct:5.1f}%", end="", flush=True)

        result = feed_and_drain(proc, samples, sample_rate, channels, progress=_progress)
        print()

    combined = result["output"]
    if combined:
        save_wav(args.output, combined, sample_rate, channels)
        print(f"[output] {len(combined) // 4} samples -> {args.output}")
    else:
        print("[output] no processed frames received.")


if __name__ == "__main__":
    _run()
```

## Next Steps

<CardGroup>
  <Card title="Processing a Single Stream" icon="waveform-lines" href="/Docs/Tutorials/Single-Stream">
    The core flow this benchmark scales up.
  </Card>

  <Card title="API Reference" icon="book" href="/API-Reference/Overview">
    Full SDK documentation for classes, enums, and callbacks.
  </Card>
</CardGroup>

## Next Steps

<CardGroup>
  <Card title="Language Translation" icon="language" href="/Docs/Tutorials/Language-Translation">
    Translate speech between languages and receive audio plus transcripts.
  </Card>

  <Card title="Processing Multiple Streams" icon="layer-group" href="/Docs/Tutorials/Processing-Multiple-Streams">
    Run many concurrent processors on one SDK instance.
  </Card>
</CardGroup>

## References

<CardGroup>
  <Card title="SDK" icon="server" href="/API-Reference/Reference/Core-Classes/RemoteSDK">
    SDK lifecycle methods including create\_sdk, activate\_api\_key, and create\_audio\_processor.
  </Card>

  <Card title="AudioProcessor" icon="waveform-lines" href="/API-Reference/Reference/Core-Classes/AudioProcessor">
    process\_frame method for audio processing.
  </Card>
</CardGroup>

***

## Need Help?

<CardGroup>
  <Card title="Email Support" icon="envelope" href="mailto:support@sanas.ai">
    [support@sanas.ai](mailto:support@sanas.ai)

    Response time: 1 business day
  </Card>

  <Card title="Support Portal" icon="ticket" href="https://support.sanas.ai">
    Raise a [support ticket](https://help.sanas.ai/) for urgent issues
  </Card>
</CardGroup>


# Speech Enhancement Overview
Source: https://developer.sanas.ai/speech-enhancement-overview

Restore and enhance voice quality in real time — denoising, speech reconstruction, de-reverberation, and bandwidth extension for crystal-clear Human ↔ Human audio.

# Speech Enhancement

> Restore, reconstruct, and enrich the human voice in real time.

Sanas **Speech Enhancement (SE)** models take degraded voice audio — noisy, reverberant, narrowband, or codec-compressed — and restore it to clear, natural, full-fidelity speech. Unlike noise cancellation, which focuses on removing unwanted sound, Speech Enhancement actively *reconstructs and enriches* the speech signal itself: cleaning up artifacts, filling in lost detail, and extending bandwidth for a richer, more intelligible result.

All Speech Enhancement models are optimized for <span>Human ↔ Human</span> experiences, where a person is on the other end of the line and perceived quality matters most.

## Core models

<CardGroup>
  <Card title="SE Voice Isolation (General)" icon="volume-slash" href="/Docs/SE-Voice-Isolation">
    `(SE1.0) VI_G_SE` Isolates intended speech by removing background noise and voices. Optimized for human listeners.
  </Card>

  <Card title="Speech Enhancement · Enhanced" icon="microphone" href="/Docs/Models/Human-Human/se-1-2">
    `SE1.2` — Denoises, de-reverberates, and reconstructs degraded speech, with bandwidth extension to 24kHz.
  </Card>

  <Card title="Speech Enhancement · Standard" icon="microphone" href="/Docs/Models/Human-Human/SE-Standard">
    **`SE2.1`** Restores and enhances voice quality for telephony audio. Low CPU footprint.
  </Card>

  <Card title="Speech Enhancement · Full-Fidelity" icon="microphone" href="/Docs/Models/Human-Human/SE-full-fidelity">
    **`SE2.2`** Full-fidelity speech enhancement with bandwidth extension to ultra-fidelity 24kHz.
  </Card>
</CardGroup>

## What Speech Enhancement does

* **Denoising** — removes residual background noise and leaked voices.
* **Speech reconstruction** — restores degraded or missing detail to improve intelligibility and clarity.
* **De-reverberation** — reduces room reverb and echo.
* **Bandwidth extension** — rebuilds high-frequency content to widen narrowband audio.
* **Codec restoration** — recovers quality lost to low-bitrate compression.

## Models

| Model | Use Case | Description | Best For |
| - | - | - | - |
| `VI_G_SE (SE 1.0)`<br />SE Voice Isolation (General) | <span>Human ↔ Human</span> | Isolates intended speech by removing background noise and voices. Optimized for human listeners. | Contact centers, conferencing, gaming |
| `SE1.2`<br />Speech Enhancement · Enhanced | <span>Human ↔ Human</span> | Full-fidelity speech enhancement model that denoises, de-reverberates, reconstructs degraded speech, and extends bandwidth to 24kHz for clear, natural human-to-human audio.when input or codec-degraded. | Restoring noisy, reverberant, or codec-degraded voice audio to premium full-fidelity quality in contact centers, conferencing, and telemedicine. |
| `SE2.1`<br />SE Standard | <span>Human ↔ Human</span> | Restores and enhances voice quality for telephony audio, outputting 8kHz | Contact centers, telephony, IVR systems |
| `SE2.2`<br />SE Full-Fidelity | <span>Human ↔ Human</span> | Full-fidelity speech enhancement model that restores voice quality and extends bandwidth from 16kHz input to ultra-fidelity 24kHz output for a richer, more natural listening experience. | Delivering premium, high-fidelity voice quality in contact centers, conferencing, telemedicine, and voice-recording restoration where clarity and vocal presence matter most. Premium contact centers, conferencing, telemedicine |

## Choose a model

<CardGroup>
  <Card title="SE Voice Isolation (General)" icon="volume-slash" href="/Docs/SE-Voice-Isolation">
    `VI_G_SE (SE1.0) `— Isolates intended speech by removing background noise and voices. Optimized for human listeners.

    * **Latency:** \~40ms
    * **Sample rate:** Up to 24kHz
    * **Range:** Primary speaker within \~1m
  </Card>

  <Card title="Speech Enhancement · Enhanced" icon="microphone" href="/Docs/Models/Human-Human/SE-Ultra-Plus">
    `SE1.2` — Denoises, de-reverberates, and reconstructs degraded speech, with bandwidth extension to 24kHz.

    * **Latency:** \~40ms
    * **Sample rate:** 16kHz → 24kHz
  </Card>

  <Card title="Speech Enhancement · Standard" icon="microphone" href="/Docs/Models/Human-Human/SE-Standard">
    `SE2.1` — Restores and enhances voice quality for telephony audio. Low CPU footprint.

    * **Latency:** 120ms
    * **Sample rate:** 16kHz → 8kHz
  </Card>

  <Card title="Speech Enhancement · Full Fidelity" icon="microphone" href="/Docs/Models/Human-Human/SE-Ultra">
    `SE2.2` — Full-fidelity speech enhancement with bandwidth extension to ultra-fidelity 24kHz.

    * **Latency:** 160ms
    * **Sample rate:** 16kHz → 24kHz
  </Card>
</CardGroup>

## How to choose

* Pick **SE Voice Isolation 1.0 (**`VI_G_SE`**)** when you need to isolate the intended speaker — removing background noise and other voices — for a human listener, in contexts like contact centers, conferencing, and gaming.
* Pick **SE Standard (`SE2.1`)** when your output path is narrowband telephony (8kHz) and you want the lowest CPU footprint — ideal for high-volume contact center and IVR deployments.
* Pick **SE Full-Fidelity (**`SE2.2`**)** when you need full-fidelity 24kHz output for premium voice experiences such as conferencing and telemedicine.
* Pick **SE Ehanced (**`SE1.2`**)** when input audio is not just narrowband but also noisy, reverberant, or degraded by low-bitrate codecs — Ultra+ restores maximum intelligibility and clarity on top of full 24kHz bandwidth extension.

<Note>
  All Speech Enhancement models accept input up to 16kHz. Input bandwidth above 8kHz is not required, and `SE2.2` and `SE1.2` render output at a full 24kHz.
</Note>