Sprach-zu-Text-API für Audio- und Videodateien

Laden Sie im Voraus aufgenommene Audio- oder Videodateien hoch und erhalten Sie ein Transkript mit Sprecherkennzeichnung und Zeitstempeln für jeden Abschnitt in 75 Ausgangssprachen mit automatischer Spracherkennung. Dasselbe Projekt übersetzt es in über 135 Sprachen und Regionen, komplett mit Untertiteln und synchronisiertem Audio.
Sprechererkennung
75 Ausgangssprachen
REST + Python-SDK
upload, transcribe, read
OAuth 2.0
# 1. upload an audio or video file by link
curl -X POST https://api.rask.ai/api/library/v1/media/link \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"link": "https://example.com/interview.mp3", "name": "interview"}'

# 2. create the project - speech recognition starts automatically
#    src_lang is optional: leave it out and the language is detected
curl -X POST https://api.rask.ai/v2/projects \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d "{\"video_id\": \"$MEDIA_ID\", \"dst_lang\": \"es-mx\"}"
GET /v2/projects/{project_id}/transcription
segments
# Read the transcript: one object per segment
curl -s https://api.rask.ai/v2/projects/$ID/transcription -H "Authorization: Bearer $TOKEN" \
  | jq '.segments[] | {speaker, start, end, text: .src.text}'
Von globalen Teams genutzt
Funktionen

Alles, was die Speech-to-Text-API liefert

Die Spracherkennung ist der erste Schritt bei jedem Rask-Projekt. Das Transkript wird in Form von Abschnitten mit Sprecherkennzeichnung und Zeitstempeln ausgegeben – bereit zum Bearbeiten, Übersetzen, Untertiteln und Vertonen im selben Projekt.

Audio- und Videodateien transkribieren

Laden Sie eine bereits aufgenommene Audio- oder Videodatei hoch oder fügen Sie einen Link ein, und die API wandelt das Gesprochene Abschnitt für Abschnitt in geschriebenen Text um.

Sprechererkennung

Verschiedene Sprecher werden automatisch erkannt, und jeder Abschnitt erhält eine Sprecherkennung wie SPEAKER_00. Geben Sie die Anzahl der Sprecher an, wenn Sie sie kennen, oder korrigieren Sie eine Kennzeichnung später.

Zeitstempel für jeden Abschnitt

Jeder Abschnitt hat eine Start- und Endzeit im Format HH:MM:SS,mmm, ideal für Untertitel, Suche und Navigation innerhalb einer Aufnahme.

75 Ausgangssprachen

Mehrsprachige Unterstützung für 75 Ausgangssprachen. Lassen Sie die Ausgangssprache leer, damit sie automatisch erkannt wird, oder legen Sie sie mit einem zweistelligen Code fest.

Übersetzung im selben Abschnitt

Jeder Abschnitt enthält den Ausgangstext und dessen Übersetzung in eine von über 135 Sprachen und Regionen, sodass Transkript und Übersetzung Zeile für Zeile synchron bleiben.

Untertitel im .srt- und .vtt-Format

Jedes fertige Projekt enthält Untertiteldateien in der Zielsprache, die genau auf die Transkriptabschnitte abgestimmt sind. Kein zweiter Anbieter für Untertitel erforderlich.

Branchenspezifische Begriffe bei der Übersetzung

Ein Glossar sorgt dafür, dass Produktnamen, Eigennamen und fachspezifischer Wortschatz bei der Übersetzung oder absichtlich in der Originalsprache einheitlich bleiben.

Das Transkript über die API bearbeiten

Ein Wort korrigieren, einen Zeitstempel anpassen, einen Sprecher neu zuweisen, einen Abschnitt hinzufügen oder löschen. Prüfer korrigieren das finale Transkript, anstatt ganz von vorne zu beginnen.

Skalieren Sie ohne Grenzen

Keine Geschwindigkeitsbegrenzungen, kein gleichzeitiges Kontingent, keine Drosselung pro Schlüssel. Führen Sie die Batch-Transkription für Ihre gesamte Audio- und Videobibliothek parallel aus.
In Aktion erleben

Sehen Sie, wie aus einem Transkript fünf Sprachversionen werden

Dasselbe Video wird auf Englisch, Französisch, Deutsch, Portugiesisch und Spanisch transkribiert, übersetzt und vertont, wobei der originale Hintergrundton erhalten bleibt.
EN flag
En
FR flag
Fr
DE flag
De
PT flag
Pt
ES flag
Es
Workflow

Drei Anfragen von der Audiodatei zum Transkript

Das Erstellen des Projekts startet die Spracherkennung, gefolgt von der Übersetzung und dem Voiceover im selben Durchgang. Verwenden Sie den /generate-Endpunkt, nachdem Sie das Transkript bearbeitet haben.
1

Audio oder Video hochladen

Senden Sie eine Audio- oder Videodatei als Multipart-Formulardaten oder posten Sie einen Link von YouTube, Google Drive, S3, Vimeo oder eine beliebige direkte URL. Sie erhalten eine Medien-ID und die Dateimetadaten, bevor Kosten anfallen.

POST /api/library/v1/media/link
2

Projekt erstellen

Übergeben Sie die Medien-ID als video_id und eine Zielsprache. Fügen Sie die Quellsprache oder die Anzahl der Sprecher hinzu, wenn Sie diese kennen. Die Erkennung startet sofort.

POST /v2/projects
3

Transkript lesen

Lesen Sie das Transkript, sobald die Segmente verfügbar sind, während die übersetzten Medien weiterverarbeitet werden. Laden Sie Untertitel- und Mediendateien herunter, wenn das Projekt abgeschlossen ist.

GET /v2/projects/{id}/transcription
Die Erkennung läuft bei vollständigen, vorab aufgezeichneten Dateien statt bei Live-Audio. Die Bearbeitungszeit variiert je nach Dateilänge, Anzahl der Sprecher und Zielsprache.
Auf Ihre Bedürfnisse zugeschnitten

Suchen Sie nach einer Sprache oder einem Format, das nicht aufgeführt ist? Sprechen Sie mit unserem Team

Eine Quellsprache außerhalb der Liste, ein von Ihrer Plattform erwartetes Transkriptformat, höherer Durchsatz oder Ihre eigene Bereitstellungsmethode: Unser Team prüft die Anforderungen Ihrer Integration und die verfügbaren Optionen.

Sprachen und Stimmen

Benötigen Sie eine Sprache außerhalb des öffentlichen Katalogs? Sprechen Sie mit unserem Team über Ihre Anforderungen und die verfügbaren Optionen.

Bereitstellung und Integration

Webhooks, Einspeisung in Ihre eigene Warteschlange, direkte Bereitstellung auf Ihrem S3 oder benutzerdefinierte Endpunkte. Sagen Sie uns einfach, wie Ihre Pipeline Daten benötigt.

Volumen und Durchsatz

Batch-Größen, Zielsprachen pro Aktion und Verarbeitungspriorität sind Teil Ihrer vertraglichen Vereinbarung und unterliegen keinen starren Produktlimits.

Sicherheit und Hosting

Datenspeicherung, SSO und SAML, Aufbewahrungsregeln und Support bei Sicherheitsprüfungen werden im Rahmen des Enterprise-Onboardings geregelt.
Anwendungsfälle

Wer nutzt eine Sprach-zu-Text-API für Videos

Plattformen mit integrierten Videos

LMS- und Kundenschulungsplattformen, Creator- und Videoplattformen, Webinar- und virtuelle Event-Tools, Videohosting- und Workflow-SaaS, digitale Adoptionsplattformen, Live-Shopping. Fügen Sie Transkripte, Untertitel und übersetzte Versionen von aufgezeichneten Videos als Funktion Ihres Produkts hinzu.

Lokalisierungs- und Produktionsagenturen

Verwenden Sie das Transkript mit Sprecherkennzeichnungen als ersten Entwurf für Ihre Prüfer, korrigieren Sie Segmente über die API und stellen Sie Untertitel, Übersetzungen und synchronisierte Versionen aus demselben Projekt bereit.

Interne, kontinuierliche Videoproduktion

Internationale Einzelhändler und E-Commerce, globale Franchises, Medienverlage, Unternehmensuniversitäten. Transkribieren Sie aufgezeichnete Schulungen, Webinare und Interviews und veröffentlichen Sie dann Untertitel und Sprachversionen für jeden Markt.
Kundenreferenzen

Echte Teams, messbare Ergebnisse

Wie Unternehmen mit Rask Videos lokalisieren – in konkreten Zahlen.
Pfeil
Pfeil
Code

Speech-to-Text-API-Codebeispiele

Ein vollständiges Beispiel in jeder Sprache: Laden Sie eine Audio- oder Videodatei hoch, erstellen Sie das Projekt, warten Sie und lesen Sie dann die Transkriptsegmente mit Sprechern und Zeitstempeln aus.
# pip install git+ssh://[email protected]/braskai/rask-sdk.git@main
import asyncio
from rask_sdk import clients, enums, schemas

async def main():
    client = clients.RaskSDKClient(client_id=CLIENT_ID, client_secret=CLIENT_SECRET)

    media = await client.create_media_link(data=schemas.MediaCreateLink(link="https://example.com/interview.mp3"))
    while media.status is enums.MediaStatus.PROCESSING:
        await asyncio.sleep(5)
        media = await client.get_media(media_id=media.id)

    # src_lang omitted: the source language is detected automatically
    job = await client.create_project(data=schemas.ProjectCreate(video_id=media.id, dst_lang="es-mx"))
    while job.status is not enums.ProjectStatus.MERGING_DONE:
        await asyncio.sleep(10)
        job = await client.get_project(project_id=job.id)

    transcript = await client.get_project_transcription(project_id=job.id)
    for seg in transcript.segments:
        print(seg.start, seg.end, seg.speaker, seg.src.text)

asyncio.run(main())
github.com/braskai/rask-sdk
async, typed models
import time, requests

AUTH = "https://rask-prod.auth.us-east-2.amazoncognito.com/oauth2/token"
API  = "https://api.rask.ai"
token = requests.post(AUTH, auth=(CLIENT_ID, CLIENT_SECRET),
                      data={"grant_type": "client_credentials"}).json()["access_token"]
h = {"Authorization": f"Bearer {token}"}

with open("interview.mp3", "rb") as f:
    media = requests.post(f"{API}/api/library/v1/media", headers=h,
                          params={"kind": "audio"}, files={"data": f}).json()
while media["status"] == "processing":
    time.sleep(5)
    media = requests.get(f"{API}/api/library/v1/media/{media['id']}", headers=h).json()

pid = requests.post(f"{API}/v2/projects", headers=h, json={
    "video_id": media["id"], "dst_lang": "es-mx", "num_speakers": 2}).json()["id"]
while requests.get(f"{API}/v2/projects/{pid}", headers=h).json()["status"] != "merging_done":
    time.sleep(10)

# write the source transcript as an .srt file
segments = requests.get(f"{API}/v2/projects/{pid}/transcription", headers=h).json()["segments"]
with open("interview_en.srt", "w") as out:
    for i, s in enumerate(segments, 1):
        out.write(f"{i}\n{s['start']} --> {s['end']}\n{s['speaker']}: {s['src']['text']}\n\n")
requests + polling
no SDK required
// no dependencies, Node 18+ global fetch
const API = 'https://api.rask.ai';
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
const auth = await fetch('https://rask-prod.auth.us-east-2.amazoncognito.com/oauth2/token', {
  method: 'POST',
  headers: { Authorization: 'Basic ' + btoa(`${CLIENT_ID}:${CLIENT_SECRET}`) },
  body: new URLSearchParams({ grant_type: 'client_credentials' }),
}).then((r) => r.json());
const h = { Authorization: `Bearer ${auth.access_token}`, 'Content-Type': 'application/json' };
const call = (method, path, body) => fetch(API + path, { method, headers: h, body: body && JSON.stringify(body) }).then((r) => r.json());

let media = await call('POST', '/api/library/v1/media/link', { link: 'https://example.com/webinar.mp4' });
while (media.status === 'processing') { await sleep(5000); media = await call('GET', `/api/library/v1/media/${media.id}`); }

let p = await call('POST', '/v2/projects', { video_id: media.id, src_lang: 'en', dst_lang: 'de-de' });
while (p.status !== 'merging_done') { await sleep(10000); p = await call('GET', `/v2/projects/${p.id}`); }

const { segments } = await call('GET', `/v2/projects/${p.id}/transcription`);
segments.forEach((s) => console.log(`[${s.start}] ${s.speaker}: ${s.src.text}`));
console.log(p.translation_vtt_path);   // German subtitles for your player
fetch, Node 18+
plain HTTP
# 1. token (valid 1 hour - cache and reuse it)
TOKEN=$(curl -s -X POST https://rask-prod.auth.us-east-2.amazoncognito.com/oauth2/token \
  -u "$CLIENT_ID:$CLIENT_SECRET" -d "grant_type=client_credentials" | jq -r .access_token)

# 2. upload a local audio file
MEDIA_ID=$(curl -s -X POST "https://api.rask.ai/api/library/v1/media?kind=audio" \
  -H "Authorization: Bearer $TOKEN" -F "data=@podcast_episode.mp3" | jq -r .id)

# 3. create the project once the media status is ready
ID=$(curl -s -X POST https://api.rask.ai/v2/projects \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d "{\"video_id\": \"$MEDIA_ID\", \"dst_lang\": \"fr-fr\"}" | jq -r .id)

# 4. when status is merging_done, read the transcript with speaker labels
curl -s https://api.rask.ai/v2/projects/$ID/transcription -H "Authorization: Bearer $TOKEN" \
  | jq -r '.segments[] | "\(.start) \(.speaker): \(.src.text)"'
local file upload
audio file, multipart
<?php
use GuzzleHttp\Client;

$http = new Client(['base_uri' => 'https://api.rask.ai']);
$json = fn($r) => json_decode($r->getBody(), true);
$auth = $json((new Client)->post('https://rask-prod.auth.us-east-2.amazoncognito.com/oauth2/token',
    ['auth' => [$clientId, $clientSecret], 'form_params' => ['grant_type' => 'client_credentials']]));
$h = ['Authorization' => 'Bearer ' . $auth['access_token']];

$media = $json($http->post('/api/library/v1/media/link', ['headers' => $h, 'json' => [
    'link' => 'https://example.com/interview.mp3']]));
while ($media['status'] === 'processing') {
    sleep(5);
    $media = $json($http->get("/api/library/v1/media/{$media['id']}", ['headers' => $h]));
}

$p = $json($http->post('/v2/projects', ['headers' => $h, 'json' => [
    'video_id' => $media['id'], 'dst_lang' => 'es-mx']]));
while ($p['status'] !== 'merging_done') {
    sleep(10);
    $p = $json($http->get("/v2/projects/{$p['id']}", ['headers' => $h]));
}

$t = $json($http->get("/v2/projects/{$p['id']}/transcription", ['headers' => $h]));
foreach ($t['segments'] as $s) {
    echo $s['start'], ' ', $s['speaker'], ': ', $s['src']['text'], PHP_EOL;
}
Guzzle 7
plain HTTP
Python ist das offizielle SDK. Die Registerkarten für Node, PHP und cURL zeigen einfache HTTP-Beispiele für dieselben Endpunkte.
Fortschritt

Wie ein Transkriptionsprojekt den Fortschritt meldet

Die Transkription ist die erste Phase eines Projekts mit dokumentierten Statusangaben, sodass Sie den tatsächlichen Fortschritt bei langen Aufnahmen anzeigen können. Sie müssen nur bei drei Gruppen aktiv werden.

Erfolgreich, hier stoppen

merging_done
Die finalen Medien- und Untertiteldateien sind bereit. Das Transkript kann früher gelesen werden, sobald seine Segmente verfügbar sind.

Wird ausgeführt, Status weiter abfragen

created
uploading
transcription_started
separate_background_started
determine_speakers_started
translation_started
voiceover_started
merging_started
Plus das passende _done Diese lassen sich perfekt in einer Benutzeroberfläche für den Fortschritt darstellen.

Fehler, Stopp und Meldung

failed
upload_failed
transcription_failed
translation_failed
voiceover_failed
merging_failed
no_audio
no_words
forbidden_link
no_audio, no_words und forbidden_link sind aussagekräftig genug, um sie direkt Ihren eigenen Nutzern zu zeigen.
Two speakers
GET /v2/projects/{id}/transcription
{"segments": [
  {"speaker": "SPEAKER_00", "start": "00:00:00,320", "end": "00:00:07,316", "status": "done",
   "src": {"text": "Thanks for joining us. Let's start with the new release.", "lang": "en"},
   "dst": {"text": "Gracias por acompañarnos. Empecemos con la nueva versión.", "lang": "es-mx"}},
  {"speaker": "SPEAKER_01", "start": "00:00:07,640", "end": "00:00:11,900", "status": "done",
   "src": {"text": "Sure. The biggest change is the reporting view.", "lang": "en"},
   "dst": {"text": "Claro. El cambio más grande es la vista de reportes.", "lang": "es-mx"}}
]}

Oder das Abfragen ganz überspringen

Verweisen Sie auf einen Webhook-Endpunkt, und jeder Statusübergang kommt als POST an, sodass Ihre Warteschlange im Moment des Geschehens auf jede Änderung reagiert. Die Webhook-Bereitstellung ist Teil des Enterprise-Onboardings.
Dokumentation lesen
preserveAspectRatio="xMidYMid meet" aria-hidden="true" role="img">
Ausgabe

Transkriptsegmente, Untertitel und übersetzte Medien

Lesen Sie das Transkript als JSON-Segmente vom Transkriptionsendpunkt. Das fertige Projekt stellt außerdem Untertiteldateien in den Formaten SRT und VTT in der Zielsprache, das übersetzte Video und bei berechtigten Tarifen die übersetzte Sprache als separate WAV-Spur bereit.
Feld
Format
Was es ist
segments
JSON
Transkript: Quelltext, Übersetzung, Sprecherkennzeichnung, Start- und Endzeit für jedes Segment
voiceover
WAV
Nur übersetzte Sprache, ohne Hintergrund, bei berechtigten Tarifen
translated_audio
WAV
Übersetzte Sprache gemischt mit dem Original-Hintergrundaudio
translation_srt_path
.srt
Untertitel in der Zielsprache, zeitlich auf die Segmente abgestimmt
translation_vtt_path
.vtt
Dieselbe Untertiteldatei als WebVTT für Webplayer
translated_video
MP4
Das übersetzte Video mit Voiceover
Steuerung

Korrigieren Sie das Transkript Segment für Segment

Die Spracherkennung liefert Ihnen einen ersten Entwurf. Korrigieren Sie ein Wort, einen Zeitstempel oder eine Sprecherkennzeichnung mit einer Anfrage pro Segment und erstellen Sie die übersetzte Version dann einfach neu. Die Neugestaltung wird nach geänderten Segmenten abgerechnet, mit einer Mindestdauer von einer Minute pro Durchgang.

Bearbeitung auf Segmentebene

Bearbeitung auf Segmentebene
Jedes Projekt stellt sein Transkript als adressierbare Segmente bereit, sodass eine Korrektur am finalen Transkript über eine einzige Patch-Anfrage erfolgt.
Das Transkript und seine Segmente abrufen
Den Quelltext anpassen, damit wir ihn neu übersetzen
Den übersetzten Text direkt anpassen, um Ihre eigenen Formulierungen beizubehalten
Zeitstempel anpassen, Segmente hinzufügen oder löschen
Sprechern eine neue Stimme zuweisen

Glossare für Fachbegriffe

Glossare für Fachbegriffe
Bei der Übersetzung des Transkripts sorgt ein Glossar dafür, dass Markennamen, Eigennamen und Fachbegriffe in jeder Version gleich bleiben oder absichtlich in der Originalsprache belassen werden.

Ein Glossar deckt ein Sprachpaar ab und gilt für alle regionalen Varianten dieser Zielsprache, sodass ein einziges spanisches Glossar es-mx und es-es gleichermaßen dient. Das Projekt speichert glossary_version, sodass spätere Änderungen bereits fertiggestellte Arbeit nicht unbemerkt verändern.
Eingabe

Unterstützte Dateiformate

Transkribieren Sie Audiodateien wie Podcasts, Interviews und aufgezeichnete Anrufe, Videos in allen gängigen Formaten oder senden Sie einfach eine URL. Wenn Sie eine nicht unterstützte Datei hochladen, lehnt die API diese ab, bevor Minuten berechnet werden.

Video

7 Formate
.mp4
.mov
.mkv
.avi
.webm
.m4v
.3gp

Audio

4 Formate
.mp3
.wav
.flac
.m4a

Metadaten, bevor Kosten entstehen

Der Media-Endpunkt gibt die Dauer, Dateigröße, den Videocodec, die Bildrate, Auflösung, den Audiocodec, die Abtastrate und das Kanal-Layout zurück. Überprüfen Sie eine Datei im Voraus und schätzen Sie die Kosten ab, da Projekte nach Audiominen oder Videominuten abgerechnet werden.
Sicherheit und Compliance

Sicherheit auf Unternehmensniveau für Audio- und Sprachdaten

Brask Inc erfüllt die Anforderungen nach SOC 2 Type II, arbeitet gemäß DSGVO und veröffentlicht den Live-Status im Trust Center, sodass Aufnahmen und Transkripte unter geprüften Standards verarbeitet werden.

Zertifizierungen

SOC 2 Type II
DSGVO
Mitglied bei CAI und C2PA

Verschlüsselung

TLS 1.2 während der Übertragung
AES-256 im Ruhezustand
Verwaltete SSE-S3-Schlüssel
Schlüsselrotation mindestens alle 12 Monate

Ihre Inhalte

Geschlossene KI-Umgebung
Niemals zum Trainieren allgemeiner Modelle verwendet
Vollständiger Export, keine Bindung an einen Anbieter

Zugang

SSO und SAML
Rollenbasierte Zugriffskontrolle
OAuth 2.0-Client-Anmeldeinformationen

Enterprise

Optionen für den Speicherort der Daten
Individuelle SLAs
Dedizierter Ansprechpartner

Stimmrechte

Synthetische Stimmen mit Nutzungsrechten
Einwilligungsbasierte Stimmklonung
KI-Sicherheitskontrollen, menschliche Überprüfung
Vergleich

Rask API im Vergleich zu einer Speech-to-Text-API plus eigener Pipeline

Eine Speech-to-Text-API wandelt Audio in Text um. Wenn dieser Text zu Untertiteln, Übersetzungen und synchronisierten Versionen werden soll, erfordert dies zusätzlichen Aufwand für die Pipeline. Hier sehen Sie dasselbe Ergebnis auf zwei verschiedene Arten erstellt.
Was Sie benötigen
Rask API
Aus Einzelteilen zusammengesetzt
Ein Transkript mit Sprecherkennzeichnungen
Im Lieferumfang enthalten
In den meisten Speech-to-Text-APIs enthalten
Zeitstempel
Pro Segment
Pro Wort bei vielen Speech-to-Text-APIs
Übersetzung des Transkripts
Dasselbe Projekt, über 135 Sprachen und regionale Optionen
Eine separate Übersetzungs-API
Untertitel im .srt- und .vtt-Format
Enthalten, in der Zielsprache
Erstellt aus Ihren eigenen Zeitdaten
Synchronisiertes Audio und Video
Im Lieferumfang enthalten
Ein TTS-Anbieter plus Ihr eigenes Mixing
Ein Segment korrigieren
Eine Patch-Anfrage, dann neu generieren
Bearbeiten und synchronisieren Sie Ihre eigenen Kopien neu
Ratenlimits
Keine
Was auch immer Ihr Anbieter vorschreibt
Echtzeit-Transkription von Live-Audio
Nutzen Sie eine Streaming-Speech-to-Text-API
Dafür entwickelt
Ein reines Transkript zum günstigsten Preis
Eine spezielle Speech-to-Text-API kostet weniger
Abrechnung pro Audiostunde
Häufig gestellte Fragen

Speech-to-Text-API: Häufig gestellte Fragen

Sie finden nicht, wonach Sie suchen? Wenden Sie sich an den Vertrieb.

Hat Rask eine Speech-to-Text-API?

Welche Sprachen können transkribiert werden?

Kann ich Audiodateien ohne Video transkribieren?

Wird Sprechererkennung (Diarisierung) unterstützt?

Gibt die API wortgenaue Zeitstempel zurück?

Wird Echtzeit-Transkription unterstützt?

Wie genau ist die Transkription?

Kann ich eigenes Vokabular oder Fachbegriffe hinzufügen?

Kann ich das Transkript als SRT-Datei erhalten?

Kann ich mein eigenes Transkript verwenden?

Wie wird die Transkription abgerechnet?

Gibt es eine kostenlose Testversion?

Wie erhalte ich API-Zugriff und einen API-Schlüssel?

Starten Sie noch heute Nachmittag mit der Synchronisation

Starten Sie noch heute Ihre erste Anfrage und sprechen Sie mit uns, wenn Sie Großkundenkonditionen oder eine seltene Sprache benötigen.