# Armenian Speech Recognition API: Transcribe Armenian Audio with cURL, Python and Node.js

> Add Armenian speech-to-text to your app with working cURL, Python and Node.js examples for the sync, async and OpenAI-compatible hispeech.ai API.

- By hispeech.ai
- URL: https://hispeech.ai/en/blog/armenian-speech-recognition-api/
- Published: 2026-10-16
- Updated: 2026-10-16
- Language: en

## Key takeaways

- One REST call transcribes an Armenian audio or video file: `POST https://api.hispeech.ai/api/v1/transcriptions/upload` with your key in the `x-auth-token` header.
- Use the **synchronous** mode for short files, the **asynchronous** mode (job ID + polling) for long ones, or the **OpenAI-compatible** endpoint to reuse the official OpenAI SDKs.
- Pick the *Formal* (`model-01052025`, default) or *Conversational* (`model-23012026`) model with the `stt_model` parameter.
- **Secure mode** keeps nothing on the server. Billing is 1 credit per second of audio.

## How can I add Armenian speech recognition to my app?

Send the audio or video file to the [hispeech.ai API](https://hispeech.ai/api.html) with your API key, and you get the Armenian text back as JSON. The API has three entry points, and all of them use the same credits and the same Armenian models:

| Endpoint | How it works | Best for |
|---|---|---|
| **Synchronous** | Upload with `wait_for_result=true`; the response contains the text. | Short files, voice messages, quick results |
| **Asynchronous** | Upload with `wait_for_result=false`, get a job ID, poll for the result. | Long recordings, batch processing, background jobs |
| **OpenAI-compatible** | `/v1/audio/transcriptions` with a Bearer token, same shape as OpenAI. | Apps already using the OpenAI SDK or OpenAI-compatible tools |

## 1. Get an API key

Sign up at [app.hispeech.ai](https://app.hispeech.ai/signup) and open **Settings** to create your API key. Keep it on your server and never ship it inside a mobile app or a web page. The examples below read it from the `HISPEECH_API_KEY` environment variable.

## 2. Transcribe a file (synchronous)

The simplest call: send the file and wait for the transcription in the same response.

**cURL**

```
curl --location 'https://api.hispeech.ai/api/v1/transcriptions/upload' \
  --header "x-auth-token: $HISPEECH_API_KEY" \
  --form 'file=@"interview.mp3"' \
  --form 'wait_for_result="true"'
```

**Python**

```
import os
import requests

API_KEY = os.environ["HISPEECH_API_KEY"]

with open("interview.mp3", "rb") as f:
    r = requests.post(
        "https://api.hispeech.ai/api/v1/transcriptions/upload",
        headers={"x-auth-token": API_KEY},
        files={"file": f},
        data={"wait_for_result": "true"},
        timeout=600,
    )
r.raise_for_status()
print(r.json()["transcription"])
```

**Node.js (18+)**

```
import { readFile } from "node:fs/promises";

const form = new FormData();
form.append("file", new Blob([await readFile("interview.mp3")]), "interview.mp3");
form.append("wait_for_result", "true");

const res = await fetch("https://api.hispeech.ai/api/v1/transcriptions/upload", {
  method: "POST",
  headers: { "x-auth-token": process.env.HISPEECH_API_KEY },
  body: form,
});
const data = await res.json();
console.log(data.transcription);
```

The response is JSON with the text and the audio length in seconds:

```
{
  "job_id": "a91f17d0-5d9a-11f1-8d6f-215414e3f380",
  "success": true,
  "secure_mode": false,
  "transcription": "Խոսում է, գրում է, պատմում է, ասում է։",
  "audio_duration": 3
}
```

## 3. Long recordings (asynchronous)

For lectures, meetings or podcasts, submit a job and come back for the result. Status checks are limited to 60 calls per hour, so check about once a minute.

**Python**

```
import os
import time
import requests

BASE = "https://api.hispeech.ai/api/v1/transcriptions"
HEADERS = {"x-auth-token": os.environ["HISPEECH_API_KEY"]}

with open("lecture.mp4", "rb") as f:
    job = requests.post(f"{BASE}/upload", headers=HEADERS,
                        files={"file": f}, data={"wait_for_result": "false"}).json()

job_id = job["job_id"]
while True:
    time.sleep(60)  # at most 60 status checks per hour
    s = requests.get(f"{BASE}/transcription-status/{job_id}", headers=HEADERS).json()
    if s["status"] == "completed":
        print(s["transcription"])
        break
    if s["status"] != "processing":
        raise RuntimeError(s)
```

In standard mode the audio and the transcription stay in your account until you delete them with `DELETE /api/v1/transcriptions` and a body of `{"transcription_id": "JOB_ID"}`.

## 4. Use the OpenAI SDK (OpenAI-compatible endpoint)

If your code already uses OpenAI for transcription, switch it to Armenian by changing the base URL and the key. Set `model` to a hispeech.ai model ID: `model-01052025` (Formal) or `model-23012026` (Conversational). OpenAI model names such as `whisper-1` are not accepted.

**Python (openai)**

```
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["HISPEECH_API_KEY"],
    base_url="https://api.hispeech.ai/api/v1",
)

with open("voice-note.m4a", "rb") as f:
    result = client.audio.transcriptions.create(model="model-01052025", file=f)

print(result.text)
```

**Node.js (openai)**

```
import fs from "node:fs";
import OpenAI from "openai";

const openai = new OpenAI({
  apiKey: process.env.HISPEECH_API_KEY,
  baseURL: "https://api.hispeech.ai/api/v1",
});

const result = await openai.audio.transcriptions.create({
  file: fs.createReadStream("voice-note.m4a"),
  model: "model-01052025", // or "model-23012026" (Conversational)
});
console.log(result.text);
```

Tools that only ask for a base URL (without `/v1`) take `https://api.hispeech.ai/api`.

## 5. What does the API return?

The upload and status endpoints return JSON. These are the fields shown in the [API docs](https://hispeech.ai/api.html):

| Field | Meaning |
|---|---|
| `job_id` | ID of the transcription. Use it to check status and to delete the result. |
| `success` | Whether the request was accepted. |
| `error` | Error details, or `null` when there is none. |
| `status` | On the status endpoint: `processing` while the job runs, `completed` when the text is ready. |
| `transcription` | The Armenian text. |
| `title` | A short title taken from the start of the text (status endpoint). |
| `audio_duration` | Length of the audio in seconds, which is also the number of credits used. |
| `secure_mode`, `ttl` | Whether Secure mode is on, and how many seconds the result is kept. |

The OpenAI-compatible endpoint returns the OpenAI shape instead: `text`, `duration`, `language`, `task` and a list of `segments`, each with `start` and `end` times in seconds.

## 6. Which model should I use?

Use Formal for documents and subtitles, and Conversational for verbatim transcripts. Choose one with the `stt_model` query parameter on the upload endpoint:

- `model-01052025`: **Formal** (default). Clean literary Armenian; best for documents and subtitles. It may turn informal speech into the standard written form.
- `model-23012026`: **Conversational**. Writes exactly what it hears, including colloquial forms like «ասում ա». Best for verbatim transcripts and call analytics.

```
curl --location 'https://api.hispeech.ai/api/v1/transcriptions/upload?stt_model=model-23012026' \
  --header "x-auth-token: $HISPEECH_API_KEY" \
  --form 'file=@"call.wav"' \
  --form 'wait_for_result="true"'
```

On the OpenAI-compatible endpoint, pass the same model ID in the `model` field instead.

## 7. How do I transcribe sensitive audio without storing it?

Add `secure_mode=true` to the upload. Use it for medical, legal or other sensitive audio. Nothing is stored: in synchronous mode you get the text and it is gone; in asynchronous mode the result is kept in memory only until you read it once, or until the time-to-live expires. Set `ttl` in seconds, from 1 to 36,000 (default 900, i.e. 15 minutes).

```
curl --location 'https://api.hispeech.ai/api/v1/transcriptions/upload' \
  --header "x-auth-token: $HISPEECH_API_KEY" \
  --form 'file=@"patient-note.m4a"' \
  --form 'wait_for_result="false"' \
  --form 'secure_mode="true"' \
  --form 'ttl="900"'
```

## 8. Which formats and limits apply?

- **Formats:** MP3, WAV, M4A, AAC, FLAC, OGG, OPUS, AIFF, WMA, AMR and more audio; MP4, MOV, MKV, WEBM, 3GP, M4V and more video.
- **Size:** up to 10 GB and 10 hours per file.
- **Speed:** about 20 seconds for one hour of audio.
- **Language:** Armenian, built for Eastern Armenian.
- **Polling:** up to 60 status checks per hour.
- **Not included:** subtitle files and subtitled video. Use the apps for those.

## 9. How much does the Armenian speech API cost?

API usage costs **1 credit per second** of audio, from the same balance as the hispeech.ai apps. Paid plans start at $3.99 per month and Business volumes scale up to 36,000,000 credits; see [pricing](https://hispeech.ai/en/#pricing). Building a startup or an indie project? Email [info@hispeech.ai](mailto:info@hispeech.ai?subject=Free%20API%20credits) and ask about free credits.

The full reference with every parameter and response is in the [API docs](https://hispeech.ai/api.html). It also has a "Copy for AI" button that copies the whole reference so you can paste it into ChatGPT, Claude or Gemini and generate integration code for your stack.

## Frequently asked questions

### Is there an API for Armenian speech-to-text?

Yes. hispeech.ai offers a REST API for Armenian speech recognition at api.hispeech.ai, with synchronous, asynchronous and OpenAI-compatible endpoints. Full reference: [hispeech.ai/api.html](https://hispeech.ai/api.html).

### Can I use the OpenAI SDK to transcribe Armenian?

Yes. Point the official OpenAI SDK at `https://api.hispeech.ai/api/v1`, use your hispeech.ai API key, and call `audio.transcriptions.create` with `model="model-01052025"` (Formal) or `model="model-23012026"` (Conversational).

### Can the API generate SRT subtitles?

Not at the moment. The API returns text transcriptions. Subtitle files (.SRT / .ASS) and subtitled video are available in the hispeech.ai web, mobile and desktop apps.

### How much does the Armenian speech API cost?

1 credit per second of audio (3,600 credits per hour), from the same balance as the apps. There is a free daily allowance, paid plans start at $3.99 per month, and startups and solo developers can ask for free API credits.

### What does the Armenian speech API return?

The upload endpoint returns JSON with a `job_id`, `success`, the `transcription` text and the `audio_duration` in seconds. The OpenAI-compatible endpoint returns the OpenAI shape: `text`, `duration` and a list of `segments` with start and end times.

### Does the API return timestamps?

The OpenAI-compatible endpoint returns `segments`, each with a start and end time in seconds and its text. The upload endpoint returns the full transcription and the audio length. For ready-made subtitle files, use the hispeech.ai apps.

### Does the API work with Western Armenian?

The models are built for Eastern Armenian. Western Armenian can be transcribed, but with noticeably more errors, so test with your own audio first.

### What audio formats does the API accept?

Common audio and video formats including MP3, WAV, M4A, AAC, FLAC, OGG, OPUS, AMR, MP4, MOV, MKV and WEBM, up to 10 GB and 10 hours per file.

## About hispeech.ai

hispeech.ai is an Armenian speech-to-text service by BlueNeyron, LLC, founded in 2023 in Yerevan. We build our own speech recognition engine for Armenian and run it on our own AI infrastructure in Armenia. It powers the hispeech.ai apps for web, iOS, Android, macOS and Windows and the developer API. https://hispeech.ai/about-en.html