> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/bark-tts.md).

# Bark TTS

Generiere realistische Sprache und Audio mit Bark AI auf Clore.ai

Erzeuge realistische Sprache und Audio mit Bark AI.

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über [CLORE.AI-Marktplatz](https://clore.ai/marketplace).
{% endhint %}

## Serveranforderungen

| Parameter | Minimum      | Empfohlen      |
| --------- | ------------ | -------------- |
| RAM       | 8 GB         | 16GB+          |
| VRAM      | 4 GB (klein) | 8 GB+ (normal) |
| Netzwerk  | 200Mbps      | 500Mbps+       |
| Startzeit | 3–5 Minuten  | -              |

{% hint style="warning" %}
**Startzeit:** Beim ersten Start werden die Bark-Modelle heruntergeladen (je nach Netzwerkgeschwindigkeit 3–5 Minuten). Ein HTTP-502-Fehler ist in dieser Zeit normal.
{% endhint %}

## Mieten auf CLORE.AI

1. Besuchen [CLORE.AI-Marktplatz](https://clore.ai/marketplace)
2. Filtern nach GPU-Typ, VRAM und Preis
3. Wähle **On-Demand** (Festpreis) oder **Spot** (Gebotspreis)
4. Konfiguriere deine Bestellung:
   * Docker-Image auswählen
   * Ports festlegen (TCP für SSH, HTTP für Web-UIs)
   * Bei Bedarf Umgebungsvariablen hinzufügen
   * Startbefehl eingeben
5. Zahlung auswählen: **CLORE**, **BTC**, oder **USDT/USDC**
6. Bestellung erstellen und auf die Bereitstellung warten

### Greife auf deinen Server zu

* Verbindungsdetails finden in **Meine Bestellungen**
* Web-Oberflächen: Verwende die HTTP-Port-URL
* SSH: `ssh -p <port> root@<proxy-address>`

## Was ist Bark?

Bark von Suno AI kann Folgendes generieren:

* Realistische Sprache in mehreren Sprachen
* Verschiedene Sprecherstimmen
* Nichtsprachliche Geräusche (Lachen, Seufzen)
* Musik und Soundeffekte
* Mehrsprachige Sprache

## Anforderungen

| Qualität | VRAM  | Empfohlen |
| -------- | ----- | --------- |
| Klein    | 4 GB  | RTX 3060  |
| Normal   | 8 GB  | RTX 3070  |
| Hoch     | 12 GB | RTX 3090  |

## Schnell bereitstellen

**Docker-Image:**

```
pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime
```

**Ports:**

```
22/tcp
7860/http
```

**Befehl:**

```bash
pip install git+https://github.com/suno-ai/bark.git gradio scipy && \\
python -c "
import gradio as gr
from bark import SAMPLE_RATE, generate_audio, preload_models
import scipy.io.wavfile as wav
import numpy as np
import tempfile

preload_models()

def generate(text, voice):
    audio = generate_audio(text, history_prompt=voice)
    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as f:
        wav.write(f.name, SAMPLE_RATE, (audio * 32767).astype(np.int16))
        return f.name

voices = ['v2/en_speaker_0', 'v2/en_speaker_1', 'v2/en_speaker_2', 'v2/en_speaker_3',
          'v2/en_speaker_4', 'v2/en_speaker_5', 'v2/en_speaker_6', 'v2/en_speaker_7',
          'v2/en_speaker_8', 'v2/en_speaker_9']

demo = gr.Interface(fn=generate, inputs=[gr.Textbox(lines=5), gr.Dropdown(voices)],
                   outputs=gr.Audio(), title='Bark TTS')
demo.launch(server_name='0.0.0.0', server_port=7860)
"
```

## Auf deinen Dienst zugreifen

Nach der Bereitstellung findest du deine `http_pub` URL in **Meine Bestellungen**:

1. Gehe zu **Meine Bestellungen** Seite
2. Klicke auf deine Bestellung
3. Finde die `http_pub` URL (z. B. `abc123.clorecloud.net`)

Verwende `https://YOUR_HTTP_PUB_URL` anstelle von `localhost` in den folgenden Beispielen.

### Prüfen, ob es funktioniert

```bash
# Prüfen, ob die Gradio-Oberfläche zugänglich ist
curl https://your-http-pub.clorecloud.net/
```

{% hint style="warning" %}
Wenn Sie einen HTTP-502-Fehler erhalten, warten Sie 3–5 Minuten – der Dienst lädt Modelle herunter.
{% endhint %}

## Installation

```bash
pip install git+https://github.com/suno-ai/bark.git
pip install scipy
```

## Grundlegende Verwendung

```python
from bark import SAMPLE_RATE, generate_audio, preload_models
import scipy.io.wavfile as wav
import numpy as np

# Modelle vorladen (werden beim ersten Lauf heruntergeladen)
preload_models()

# Audio generieren
text = "Hallo, das ist ein Test von Bark Text-zu-Sprache."
audio = generate_audio(text)

# Als WAV speichern
wav.write("output.wav", SAMPLE_RATE, (audio * 32767).astype(np.int16))
```

## Stimmenauswahl

### Integrierte Stimmen

```python

# Englische Sprecher (0-9)
audio = generate_audio("Hallo!", history_prompt="v2/en_speaker_0")
audio = generate_audio("Hallo!", history_prompt="v2/en_speaker_3")
audio = generate_audio("Hallo!", history_prompt="v2/en_speaker_9")

# Andere Sprachen
audio = generate_audio("Bonjour!", history_prompt="v2/fr_speaker_0")  # Französisch
audio = generate_audio("Hallo!", history_prompt="v2/de_speaker_0")    # Deutsch
audio = generate_audio("Hola!", history_prompt="v2/es_speaker_0")     # Spanisch
audio = generate_audio("Ciao!", history_prompt="v2/it_speaker_0")     # Italienisch
audio = generate_audio("Olá!", history_prompt="v2/pt_speaker_0")      # Portugiesisch
audio = generate_audio("Привет!", history_prompt="v2/ru_speaker_0")   # Russisch
audio = generate_audio("こんにちは!", history_prompt="v2/ja_speaker_0") # Japanisch
audio = generate_audio("你好!", history_prompt="v2/zh_speaker_0")      # Chinesisch
```

### Verfügbare Sprachen

| Sprache       | Code | Sprecher |
| ------------- | ---- | -------- |
| Englisch      | en   | 0-9      |
| Deutsch       | de   | 0-9      |
| Spanisch      | es   | 0-9      |
| Französisch   | fr   | 0-9      |
| Hindi         | it   | 0-9      |
| Italienisch   | it   | 0-9      |
| Japanisch     | ja   | 0-9      |
| Koreanisch    | ko   | 0-9      |
| Polnisch      | pl   | 0-9      |
| Portugiesisch | pt   | 0-9      |
| Russisch      | ru   | 0-9      |
| Türkisch      | tr   | 0-9      |
| Chinesisch    | zh   | 0-9      |

## Nichtsprachliche Klänge

Bark kann nichtsprachliches Audio generieren:

```python

# Lachen
audio = generate_audio("Hallo! [lacht] Das ist so lustig!")

# Seufzen
audio = generate_audio("[seufzt] Ich bin heute so müde.")

# Keuchen
audio = generate_audio("[keucht] Oh mein Gott!")

# Räuspern
audio = generate_audio("[räuspert sich] Ähem, bitte Aufmerksamkeit.")

# Musiknoten
audio = generate_audio("♪ La la la ♪")
```

## Langform-Audio

Für Texte länger als 13 Sekunden:

```python
from bark import generate_audio
from bark.generation import SAMPLE_RATE
import numpy as np

def generate_long_audio(text, voice="v2/en_speaker_6")】【：】【“】【t_3ae97a4e":"# In Sätze aufteilen","t_6c31ae01":"sentences = text.replace(\".\", \".|\").replace(\"?\", \"?|\").replace(\"!\", \"!|\").split(\"|\")","t_860d3baa":"sentences = [s.strip() for s in sentences if s.strip()]","t_a9340f9e":"audio_segments = []","t_2d3c20f8":"for sentence in sentences:","t_a06d93c0":"audio = generate_audio(sentence, history_prompt=voice)","t_717bbcb1":"audio_segments.append(audio)","t_d49fbeb1":"# Kleine Pause zwischen Sätzen hinzufügen","t_7410572f":"audio_segments.append(np.zeros(int(0.25 * SAMPLE_RATE)))","t_e9782440":"return np.concatenate(audio_segments)","t_8b213ec9":"Dies ist ein längerer Text, der in mehrere Segmente aufgeteilt wird.","t_9103dfcb":"Jedes Segment wird separat generiert. Danach werden sie aneinandergereiht.","t_907baa4b":"So kann Audio beliebiger Länge erzeugt werden.","t_93b38d5d":"audio = generate_long_audio(long_text)","t_9dc9a264":"Eigene Stimm-Prompts erstellen:","t_883e90ed":"from bark.generation import preload_models, generate_text_semantic","t_b37b0af6":"from bark.api import semantic_to_waveform","t_68cca8cd":"# Mit bestimmten Eigenschaften generieren","t_1e110213":"# Der Prompt kann eine Sprecherbeschreibung enthalten","t_5078a34c":"# Zuerst eine Referenz generieren","t_93c305b6":"voice_prompt = \"v2/en_speaker_6\"","t_d4c14598":"text = \"So klinge ich, wenn ich normal spreche.\"","t_e7f6f90e":"audio = generate_audio(text, history_prompt=voice_prompt)","t_5069d61d":"# Als benutzerdefinierte Stimme speichern (vereinfachtes Beispiel)","t_a68076cb":"np.savez(\"custom_voice.npz\", audio=audio)","t_2857969e":"\"Willkommen zu unserem Podcast.\",","t_3f82756d":"\"Heute sprechen wir über künstliche Intelligenz.\",","t_dff8c699":"\"Lassen Sie uns mit der Einführung beginnen.\",","t_918801cc":"output_dir = \"./audio_clips\"","t_60d0287c":"voice = \"v2/en_speaker_6\"","t_804a8d1d":"print(f\"Generiere {i+1}/{len(texts)}\")","t_3513ca1a":"wav.write(","t_69383904":"os.path.join(output_dir, f\"clip_{i:03d}.wav\"),","t_1303064c":"SAMPLE_RATE,","t_d5897104":"(audio * 32767).astype(np.int16)","t_dcbc04f9":"from bark import generate_audio, preload_models, SAMPLE_RATE","t_ae8cfe5c":"async def generate_speech(text: str, voice: str = \"v2/en_speaker_6\"):","t_e4683167":"return FileResponse(f.name, media_type=\"audio/wav\")","t_f9a930f7":"curl -X POST \"http://localhost:8000/generate?text=Hello%20world&voice=v2/en_speaker_6\" \\\","t_ec4082c2":"--output speech.wav","t_eb087929":"Bei begrenztem VRAM","t_d04f5d40":"# Kleineres Modell verwenden","t_9e83e669":"os.environ[\"SUNO_USE_SMALL_MODELS\"] = \"1\"","t_3af8557d":"# Auf CPU auslagern","t_65bc6296":"os.environ[\"SUNO_OFFLOAD_CPU\"] = \"1\"","t_c0f01e8b":"audio = generate_audio(\"Hallo Welt\")","t_ad926e75":"FP16 aktivieren","t_852bdf64":"os.environ[\"SUNO_ENABLE_MPS\"] = \"0\"","t_ec273d1f":"audio = generate_audio(\"Hallo!\", history_prompt=\"v2/en_speaker_6\")","t_8459d79c":"Mit anderem Audio kombinieren","t_febf1336":"from pydub import AudioSegment","t_d874558d":"def bark_to_pydub(audio_array):","t_2fe58be2":"wav.write(f.name, SAMPLE_RATE, (audio_array * 32767).astype(np.int16))","t_26d92dc7":"return AudioSegment.from_wav(f.name)","t_434120aa":"speech = generate_audio(\"Willkommen zur Show!\")","t_a5da6c58":"speech_audio = bark_to_pydub(speech)","t_41ab335b":"# Hintergrundmusik laden","t_6180c734":"music = AudioSegment.from_mp3(\"background.mp3\")","t_becc363a":"# Zusammen mischen","t_d58abb8d":"music = music - 20  # Lautstärke der Musik verringern","t_68968397":"combined = speech_audio.overlay(music)","t_05ac5728":"combined.export(\"output.mp3\", format=\"mp3\")","t_c16c5a0c":"Zeit (10 Wörter)","t_37113d91":"~60s","t_5880072e":"Vergleich mit anderen TTS","t_3aaf3895":"Coqui","t_5aff6e70":"Piper","t_91046356":"Nichtverbal","t_3bc594cd":"1 GB","t_c50ebc64":"# Kleine Modelle verwenden","t_d53c00e8":"GPU verwenden (nicht CPU)","t_f6531629":"Modelle zwischen den Generierungen geladen lassen","t_f31f5a1b":"Kürzere Segmente generieren","t_b325204f":"Verschiedene Sprecher ausprobieren","t_1dee3bb3":"Langen Text in Sätze aufteilen","t_6918a2da":"Sonderzeichen vermeiden","t_dd38c7f5":"RVC-Stimmenklonung","t_e0f4042d":"AudioCraft-Musik"} }<|ghissue|>ន្តો 0jsonp to=final  大发pkcode ￣奇米影视
    # In Sätze aufteilen
    sentences = text.replace(".", ".|").replace("?", "?|").replace("!", "!|").split("|")
    sentences = [s.strip() for s in sentences if s.strip()]

    audio_segments = []
    for sentence in sentences:
        audio = generate_audio(sentence, history_prompt=voice)
        audio_segments.append(audio)
        # Kleine Pause zwischen Sätzen hinzufügen
        audio_segments.append(np.zeros(int(0.25 * SAMPLE_RATE)))

    return np.concatenate(audio_segments)

long_text = """
Dies ist ein längerer Text, der in mehrere Segmente aufgeteilt wird.
Jedes Segment wird separat generiert. Danach werden sie aneinandergereiht.
So kann Audio beliebiger Länge erzeugt werden.
"""

audio = generate_long_audio(long_text)
```

## Stimmenklonierung

Eigene Stimm-Prompts erstellen:

```python
from bark.generation import preload_models, generate_text_semantic
from bark.api import semantic_to_waveform
from bark import generate_audio, SAMPLE_RATE
import numpy as np

# Mit bestimmten Eigenschaften generieren

# Der Prompt kann eine Sprecherbeschreibung enthalten

# Zuerst eine Referenz generieren
voice_prompt = "v2/en_speaker_6"
text = "So klinge ich, wenn ich normal spreche."
audio = generate_audio(text, history_prompt=voice_prompt)

# Als benutzerdefinierte Stimme speichern (vereinfachtes Beispiel)
np.savez("custom_voice.npz", audio=audio)
```

## Batch-Verarbeitung

```python
import os
from bark import generate_audio, SAMPLE_RATE
import scipy.io.wavfile as wav
import numpy as np

texts = [
    "Willkommen zu unserem Podcast.",
    "Heute sprechen wir über künstliche Intelligenz.",
    "Lassen Sie uns mit der Einführung beginnen.",
]

output_dir = "./audio_clips"
os.makedirs(output_dir, exist_ok=True)

voice = "v2/en_speaker_6"

for i, text in enumerate(texts):
    print(f"Generiere {i+1}/{len(texts)}")
    audio = generate_audio(text, history_prompt=voice)
    wav.write(
        os.path.join(output_dir, f"clip_{i:03d}.wav"),
        SAMPLE_RATE,
        (audio * 32767).astype(np.int16)
    )
```

## API-Server

```python
from fastapi import FastAPI
from fastapi.responses import FileResponse
from bark import generate_audio, preload_models, SAMPLE_RATE
import scipy.io.wavfile as wav
import numpy as np
import tempfile
import os

app = FastAPI()
preload_models()

@app.post("/generate")
async def generate_speech(text: str, voice: str = "v2/en_speaker_6"):
    audio = generate_audio(text, history_prompt=voice)

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        wav.write(f.name, SAMPLE_RATE, (audio * 32767).astype(np.int16))
        return FileResponse(f.name, media_type="audio/wav")

# Ausführen: uvicorn server:app --host 0.0.0.0 --port 8000
```

### Verwendung

```bash
curl -X POST "http://localhost:8000/generate?text=Hello%20world&voice=v2/en_speaker_6" \\\
    --output speech.wav
```

## Speicheroptimierung

### Bei begrenztem VRAM

```python
import os

# Kleineres Modell verwenden
os.environ["SUNO_USE_SMALL_MODELS"] = "1"

# Auf CPU auslagern
os.environ["SUNO_OFFLOAD_CPU"] = "1"

from bark import generate_audio
audio = generate_audio("Hallo Welt")
```

### FP16 aktivieren

```python
os.environ["SUNO_ENABLE_MPS"] = "0"

from bark import generate_audio
audio = generate_audio("Hallo!", history_prompt="v2/en_speaker_6")
```

## Mit anderem Audio kombinieren

```python
from pydub import AudioSegment
import numpy as np
from bark import generate_audio, SAMPLE_RATE
import scipy.io.wavfile as wav
import tempfile

def bark_to_pydub(audio_array):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        wav.write(f.name, SAMPLE_RATE, (audio_array * 32767).astype(np.int16))
        return AudioSegment.from_wav(f.name)

# Sprache erzeugen
speech = generate_audio("Willkommen zur Show!")
speech_audio = bark_to_pydub(speech)

# Hintergrundmusik laden
music = AudioSegment.from_mp3("background.mp3")

# Zusammen mischen
music = music - 20  # Lautstärke der Musik verringern
combined = speech_audio.overlay(music)
combined.export("output.mp3", format="mp3")
```

## Leistung

| Modus  | GPU      | Zeit (10 Wörter) |
| ------ | -------- | ---------------- |
| Normal | RTX 3090 | \~5 s            |
| Normal | RTX 4090 | \~3s             |
| Klein  | RTX 3060 | \~8s             |
| CPU    | -        | \~60s            |

## Vergleich mit anderen TTS

| Funktion        | Bark      | Coqui     | Piper   |
| --------------- | --------- | --------- | ------- |
| Qualität        | Am besten | Großartig | Gut     |
| Geschwindigkeit | Langsam   | Mittel    | Schnell |
| Sprachen        | 13+       | 20+       | 30+     |
| Nichtverbal     | Ja        | Nein      | Nein    |
| VRAM            | 8 GB+     | 4 GB      | 1 GB    |

## Fehlerbehebung

### Speicher erschöpft

```python

# Kleine Modelle verwenden
os.environ["SUNO_USE_SMALL_MODELS"] = "1"
os.environ["SUNO_OFFLOAD_CPU"] = "1"
```

### Langsame Generierung

* GPU verwenden (nicht CPU)
* Modelle zwischen den Generierungen geladen lassen
* Kürzere Segmente generieren

### Probleme mit der Audioqualität

* Verschiedene Sprecher ausprobieren
* Langen Text in Sätze aufteilen
* Sonderzeichen vermeiden

## Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise (Stand 2024):

| GPU       | Stundensatz | Tagessatz | 4-Stunden-Sitzung |
| --------- | ----------- | --------- | ----------------- |
| RTX 3060  | \~$0.03     | \~$0.70   | \~$0.12           |
| RTX 3090  | \~$0.06     | \~$1.50   | \~$0.25           |
| RTX 4090  | \~$0.10     | \~$2.30   | \~$0.40           |
| A100 40GB | \~$0.17     | \~$4.00   | \~$0.70           |
| A100 80GB | \~$0.25     | \~$6.00   | \~$1.00           |

*Die Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie* [*CLORE.AI-Marktplatz*](https://clore.ai/marketplace) *für aktuelle Preise.*

**Geld sparen:**

* Nutzen Sie den **Spot** Markt für unterbrechbare Arbeit — etwa ein Drittel der Server bietet Spot-Preise unter dem On-Demand-Preis (Median ca. 13 % Rabatt), der Rest ist gleichauf
* Bezahlen Sie mit **CLORE** Tokens
* Vergleichen Sie Preise zwischen verschiedenen Anbietern

## Nächste Schritte

* [RVC-Stimmenklonung](/guides/guides_v2-de/audio-and-stimme/rvc-voice-clone.md)
* [Whisper-Transkription](/guides/guides_v2-de/audio-and-stimme/whisper-transcription.md)
* [AudioCraft-Musik](/guides/guides_v2-de/audio-and-stimme/audiocraft-music.md)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/bark-tts.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.