What makes gladia-sdk-integration notable?

1.3K downloads. Trust evidence available

How should gladia-sdk-integration be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

gladia-sdk-integration

Install and configure the official Gladia SDKs (@gladiaio/sdk for JS/TS, gladiaio-sdk for Python). Use when the user asks about SDK setup, client initialization, API key configuration, choosing between JS and Python, browser usage, retry/timeout settings, error handling, or SDK vs raw API decisions. The SDK is the recommended default for all Gladia integrations.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.3k

Updated

Oct 10, 2026

Version

1.0.5

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.3K downloads reported by the source. Last updated 10/10/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 10, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 10, 2026
Adoption signal: 1.3K downloadsadoption · observed Oct 10, 2026
Latest release: 1.0.5release · observed Oct 2, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s170451ybbxgxcc4es3g96b4fs8823td:gladia-sdk-integration

Install using `clawhub skill install s170451ybbxgxcc4es3g96b4fs8823td:gladia-sdk-integration` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/gladiaio/gladia-sdk-integration before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-gladiaio-gladia-sdk-integration/snapshot"

Documentation

CLAWHUB

145,401 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: gladia-sdk-integration
description: Install and configure the official Gladia SDKs (@gladiaio/sdk for JS/TS, gladiaio-sdk for Python). Use when the user asks about SDK setup, client initialization, API key configuration, choosing between JS and Python, browser usage, retry/timeout settings, error handling, or SDK vs raw API decisions. The SDK is the recommended default for all Gladia integrations.
license: MIT
---

# SDK Integration

Official SDKs for integrating Gladia's speech-to-text API. Both SDKs share the same design and are generated from the Gladia OpenAPI schema.

> **The SDK is the default for all Gladia integrations.** Always use the SDK unless there is a specific, documented reason not to (see decision guide below).

## When to Use

- User asks about installing, configuring, or initializing the Gladia SDK
- Setting up API key, region, retry, timeout, or WebSocket configuration
- Questions about SDK architecture, client methods, or type exports
- Choosing between JS/TS and Python SDK, or between SDK and raw API
- Browser-based integration, proxy setup, or bundle format questions
- Error handling patterns for Gladia API responses

**When NOT to use:** If the user is asking about a specific transcription use case (pre-recorded files or live streaming), start with the relevant use-case skill ([gladia-pre-recorded-transcription](../gladia-pre-recorded-transcription/SKILL.md) or [gladia-live-transcription](../gladia-live-transcription/SKILL.md)) instead — those skills reference back here for setup details.

## When to Use SDK vs Raw API

| Scenario                                 | Approach                                                                                                      |
| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| Any JS/TS or Python project              | **SDK** — always                                                                                              |
| Browser app                              | **SDK** — JS SDK supports ESM/IIFE bundles                                                                    |
| Need custom HTTP client or middleware    | SDK first; use `httpHeaders` / `httpTimeout` config. Fall back to raw REST only if SDK config is insufficient |
| Language without an SDK (Go, Java, etc.) | Raw REST/WebSocket (SDK unavailable)                                                                          |
| User explicitly requests raw calls       | Raw REST/WebSocket                                                                                            |
| CI script or one-off curl test           | Raw REST is acceptable                                                                                        |
| Terminal one-off with gladia-cli on PATH | **CLI** — see [gladia-using-cli](../gladia-using-cli/SKILL.md)                                                |

When i

_meta.json

{
  "ownerId": "kn7fs6cmj9hqg7232sbkacf31d882wp2",
  "slug": "gladia-sdk-integration",
  "version": "1.0.5",
  "publishedAt": 1790953718008
}

references/client-config.md

# Full Client Configuration Reference

Complete configuration options for `GladiaClient` constructor.

## Contents

- Full Config Example (JavaScript/TypeScript)
- Config Summary Table

## Full Config Example

```typescript
const client = new GladiaClient({
  apiKey: "your-key",
  apiUrl: "https://api.gladia.io",
  region: "eu-west",

  // HTTP settings
  httpHeaders: { "X-Custom-Header": "value" },
  httpTimeout: 10000, // 10s default
  httpRetry: {
    maxRetries: 3,
    retryDelay: 1000,
  },

  // WebSocket settings
  wsRetry: {
    maxRetries: 5,
    retryDelay: 1000,
  },
  wsTimeout: 30000,

  // Pre-recorded operation timeouts
  prerecordedTimeouts: {
    transcribe: 7200000, // 2 hours (full flow)
    poll: 7200000,
    upload: 300000, // 5 minutes
    create: 30000,
    get: 10000,
    delete: 10000,
    getFile: 60000,
  },

  // Live operation timeouts
  liveTimeouts: {
    get: 10000,
    delete: 10000,
    getFile: 60000,
  },
});
```

## Config Summary

| Option                  | Type     | Default                 | Description                |
| ----------------------- | -------- | ----------------------- | -------------------------- |
| `apiKey`                | `string` | `GLADIA_API_KEY` env    | API key                    |
| `apiUrl`                | `string` | `https://api.gladia.io` | Base API URL               |
| `region`                | `string` | `GLADIA_REGION` env     | `eu-west` or `us-west`     |
| `httpHeaders`           | `object` | `{}`                    | Custom HTTP headers        |
| `httpTimeout`           | `number` | `10000`                 | HTTP request timeout (ms)  |
| `httpRetry.maxRetries`  | `number` | `3`                     | Max HTTP retries           |
| `httpRetry.retryDelay`  | `number` | `1000`                  | Delay between retries (ms) |
| `wsRetry.maxRetries`    | `number` | `5`                     | Max WebSocket reconnects   |
| `wsRetry.retryDelay`    | `number` | `1000`                  | WS reconnect delay (ms)    |
| `wsTimeout`             | `number` | `30000`                 | WebSocket timeout (ms)     |
| `prerecordedTimeouts.*` | `number` | varies                  | Per-operation timeouts     |
| `liveTimeouts.*`        | `number` | varies                  | Per-operation timeouts     |

references/javascript.md

# JavaScript / TypeScript SDK

Patterns and details specific to the `@gladiaio/sdk` package.

## Contents

- Package Info
- Browser Usage (ESM, IIFE, API key security via proxy)
- File Upload in Browsers
- Node.js Specifics (file paths, WebSocket for Node < 22, streaming from file/mic)
- Untyped API
- TypeScript Types
- Error Handling
- Live Session Event Typing
- CDN / IIFE Bundle
- Package Size

## Package Info

- **npm**: [@gladiaio/sdk](https://www.npmjs.com/package/@gladiaio/sdk)
- **Version**: 2.1.0
- **Runtime**: Node.js 20+, Bun, browsers
- **Bundle formats**: ESM, CJS, IIFE (via unpkg/jsdelivr)
- **Dependencies**: 0 runtime deps
- **Peer deps**: `ws` (only for Node < 22, which lacks native WebSocket)

## Browser Usage

The SDK works in browsers out of the box. Use ESM imports or the IIFE bundle:

```html
<script src="https://unpkg.com/@gladiaio/sdk/dist/index.iife.js"></script>
<script>
  const client = new GladiaSDK.GladiaClient({ apiKey: "..." });
</script>
```

### API Key Security in Browsers

Never expose your API key in client-side code for production. Instead, use a proxy:

```typescript
// Point the SDK at your backend proxy (no apiKey needed)
const client = new GladiaClient({
  apiUrl: "https://your-server.com/api/gladia",
});
```

Your backend proxy adds the `x-gladia-key` header before forwarding to `api.gladia.io`.

## File Upload in Browsers

Use `File` or `Blob` objects for uploads:

```typescript
const fileInput = document.querySelector('input[type="file"]');
const file = fileInput.files[0];

const result = await client.preRecorded().transcribe(file, {
  language_config: { languages: ["en"] },
});
```

## Node.js Specifics

### File path input

```typescript
// Node: pass a file path string
const result = await client
  .preRecorded()
  .transcribe("./recordings/meeting.wav", options);
```

### WebSocket for Node < 22

Node versions before 22 don't have native WebSocket. Install the `ws` package:

```bash
npm install ws
```

The SDK auto-detects and uses it. Node 22+ uses the built-in `WebSocket` global.

### Streaming audio from a file

```typescript
import { createReadStream } from "fs";

const session = client.liveV2().startSession({
  encoding: "wav/pcm",
  sample_rate: 16000,
  bit_depth: 16,
  channels: 1,
  language_config: { languages: ["en"] },
});

session.once("started", () => {
  const stream = createReadStream("./audio.pcm", { highWaterMark: 3200 });
  stream.on("data", (chunk) => session.sendAudio(chunk));
  stream.on("end", () => session.stopRecording());
});
```

### Streaming from microphone (Node)

Use a library like `node-mic` or `node-record-lpcm16`:

```typescript
import mic from "mic";

const micInstance = mic({ rate: 16000, bitwidth: 16, channels: 1 });
const micStream = micInstance.getAudioStream();

session.once("started", () => {
  micStream.on("data", (chunk) => session.sendAudio(chunk));
  micInstance.start();
});

// Stop
micInstance.stop();
session.stopRecording();
```

## Untyped API

For max

references/python.md

# Python SDK

Patterns and details specific to the `gladiaio-sdk` package.

## Contents

- Package Info
- Sync vs Async (including async live session)
- Client Method Aliases
- Typed Request Objects (dataclass-style and dict alternative)
- File Input Types
- Session ID Access
- Error Types
- Event Handling (pyee EventEmitter pattern)
- Streaming Audio from File
- Streaming from Microphone (PyAudio)
- Response Access
- Package Structure (exports)

## Package Info

- **PyPI**: [gladiaio-sdk](https://pypi.org/project/gladiaio-sdk/)
- **Version**: 2.1.0
- **Runtime**: Python 3.10+
- **Dependencies**: httpx, websockets, pyee

## Sync vs Async

The Python SDK provides both synchronous and asynchronous clients:

```python
from gladiaio_sdk import GladiaClient

client = GladiaClient(api_key="YOUR_KEY")

# Sync
result = client.prerecorded().transcribe("audio.mp3", options)

# Async
result = await client.prerecorded_async().transcribe("audio.mp3", options)
```

### Async live session

```python
import asyncio
from gladiaio_sdk import GladiaClient, LiveV2InitRequest, LiveV2LanguageConfig

async def main():
    client = GladiaClient(api_key="YOUR_KEY")
    live_client = client.live_async()
    session_done = asyncio.Event()

    session = live_client.start_session(
        LiveV2InitRequest(
            model="solaria-1",
            encoding="wav/pcm",
            sample_rate=16000,
            bit_depth=16,
            channels=1,
            language_config=LiveV2LanguageConfig(languages=["en"]),
        )
    )

    @session.once("ended")
    def on_ended(msg):
        session_done.set()

    session.send_audio(audio_bytes)
    session.stop_recording()
    await session_done.wait()

asyncio.run(main())
```

## Client Method Aliases

| Primary                      | Aliases                                             |
| ---------------------------- | --------------------------------------------------- |
| `client.prerecorded()`       | `client.pre_recorded()`, `client.pre_recorded_v2()` |
| `client.prerecorded_async()` | `client.pre_recorded_async()`                       |
| `client.live()`              | `client.live_v2()`                                  |
| `client.live_async()`        | `client.live_v2_async()`                            |

## Typed Request Objects

Python uses dataclass-style request objects for type safety:

```python
from gladiaio_sdk import (
    LiveV2InitRequest,
    LiveV2LanguageConfig,
    LiveV2MessagesConfig,
    LiveV2PreProcessing,
    LiveV2RealtimeProcessing,
    LiveV2PostProcessing,
)

request = LiveV2InitRequest(
    model="solaria-1",
    encoding="wav/pcm",
    sample_rate=16000,
    bit_depth=16,
    channels=1,
    language_config=LiveV2LanguageConfig(
        languages=["en", "fr"],
        code_switching=True,
    ),
    messages_config=LiveV2MessagesConfig(
        receive_partial_transcripts=True,
        receive_speech_events=True,
    ),
    pre_processing=LiveV2PreProcessing(
        audio_enhancer=True,

Github ReposUpdated 1d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.