Meta developed and released the Meta Llama 3.1 family of large language models (LLMs), a collection of pretrained and instruction tuned generative text models in 8B, 70B and 405B sizes

Meta-Llama-3.1-405B-Instruct

Qwen2.5 is a model pretrained on a large-scale dataset of up to 18 trillion tokens, offering significant improvements in knowledge, coding, mathematics, and instruction following compared to its predecessor Qwen2. The model also features enhanced capabilities in generating long texts, understanding structured data, and generating structured outputs, while supporting multilingual capabilities for over 29 languages.

Qwen2.5-72B-Instruct

Meta-Llama-3.1-70B-Instruct

Meta-Llama-3.1-8B-Instruct

12B model trained jointly by Mistral AI and NVIDIA, it significantly outperforms existing models smaller or similar in size.

Mistral-Nemo-Instruct-2407

MiniCPM-Llama3-V-2_5

FLUX.1-dev is a state-of-the-art 12 billion parameter rectified flow transformer developed by Black Forest Labs. This model excels in text-to-image generation, providing highly accurate and detailed outputs. It is particularly well-regarded for its ability to follow complex prompts and generate anatomically accurate images, especially with challenging details like hands and faces.

FLUX-1-dev

FLUX.1 [schnell] is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions. This model offers cutting-edge output quality and competitive prompt following, matching the performance of closed source alternatives. Trained using latent adversarial diffusion distillation, FLUX.1 [schnell] can generate high-quality images in only 1 to 4 steps. 

FLUX-1-schnell

Whisper is a general-purpose speech recognition model. It is trained on a large dataset of diverse audio and is also a multi-task model that can perform multilingual speech recognition as well as speech translation and language identification.

whisper-large-v3

Distil-Whisper was proposed in the paper Robust Knowledge Distillation via Large-Scale Pseudo Labelling.  This is the third and final installment of the Distil-Whisper English series. It the knowledge distilled version of OpenAI's Whisper large-v3, the latest and most performant Whisper model to date.  Compared to previous Distil-Whisper models, the distillation procedure for distil-large-v3 has been adapted to give superior long-form transcription accuracy with OpenAI's sequential long-form algorithm.

distil-large-v3

Text-to-Speech (TTS) technology converts written text into spoken words using advanced speech synthesis. TTS systems are used in applications like virtual assistants, accessibility tools for visually impaired users, and language learning software, enabling seamless human-computer interaction.

Gemma is a family of lightweight, state-of-the-art open models from Google. Gemma-2-27B delivers the best performance for its size class, and even offers competitive alternatives to models more than twice its size. 

gemma-2-27b-it

Gemma is a family of lightweight, state-of-the-art open models from Google. The 9B Gemma 2 model delivers class-leading performance, outperforming Llama 3 8B and other open models in its size category.

gemma-2-9b-it

Euryale 70B v2.1 is a model focused on creative roleplay from Sao10k

L3-70B-Euryale-v2.1

Model Details Meta developed and released the Meta Llama 3 family of large language models (LLMs), a collection of pretrained and instruction tuned generative text models in 8 and 70B sizes.

Meta-Llama-3-70B-Instruct

The 72 billion parameter Qwen2 excels in language understanding, multilingual capabilities, coding, mathematics, and reasoning.

Qwen2-72B-Instruct

Mistral-7B-Instruct-v0.3 is an instruction-tuned model, next iteration of of Mistral 7B that has larger vocabulary, newer tokenizer and supports function calling.

Mistral-7B-Instruct-v0.3

Meta developed and released the Meta Llama 3 family of large language models (LLMs), a collection of pretrained and instruction tuned generative text models in 8 and 70B sizes.

Meta-Llama-3-8B-Instruct

WizardLM-2 8x22B is Microsoft AI's most advanced Wizard model. It demonstrates highly competitive performance compared to those leading proprietary models.

WizardLM-2-8x22B

WizardLM-2 7B is the smaller variant of Microsoft AI's latest Wizard model. It is the fastest and achieves comparable performance with existing 10x larger open-source leading models

WizardLM-2-7B

Mixtral is mixture of expert large language model (LLM) from Mistral AI. This is state of the art machine learning model using a mixture 8 of experts (MoE) 7b models. During inference 2 expers are selected. This architecture allows large models to be fast and cheap at inference. The Mixtral-8x7B outperforms Llama 2 70B on most benchmarks.

Mixtral-8x7B-Instruct-v0.1

A Mythomax/MLewd_13B-style merge of selected 70B models  A multi-model merge of several  LLaMA2 70B finetunes for roleplaying and creative work. The goal was to create a model that combines creativity with intelligence for an enhanced experience.

lzlv_70b_fp16_hf

BGE embedding is a general Embedding Model. It is pre-trained using retromae and trained on large-scale pair data using contrastive learning. Note that the goal of pre-training is to reconstruct the text, and the pre-trained model cannot be used for similarity calculation directly, it needs to be fine-tuned

bge-large-en-v1.5

You can use cURL or any other http client to run inferences:

```bash
curl -X POST \
    -d '{"text": "I'm beginnin' to feel like a Rap God, Rap God\nAll my people from the front to the back nod, back nod\nNow, who thinks their arms are long enough to slap box, slap box?\nThey said I rap like a robot, so call me Rap-bot"}'  \
    -H "Authorization: bearer $DEEPINFRA_TOKEN"  \
    -H 'Content-Type: application/json'  \
    'https://api.deepinfra.com/v1/inference/deepinfra/tts'
```

which will give you back something similar to:

```json
{
  "audio": null,
  "input_character_length": 0,
  "request_id": null,
  "inference_status": {
    "status": "unknown",
    "runtime_ms": 0,
    "cost": 0.0,
    "tokens_generated": 0,
    "tokens_input": 0
  }
}

```


You can use our command-line tool [deepctl](/docs/advanced/deepctl) to run
inferences:

```bash
deepctl infer \
    -m 'deepinfra/tts'  \
    -i 'text=I'"'"'m beginnin'"'"' to feel like a Rap God, Rap God
All my people from the front to the back nod, back nod
Now, who thinks their arms are long enough to slap box, slap box?
They said I rap like a robot, so call me Rap-bot'
```

which will give you back something similar to:

```json
{
  "audio": null,
  "input_character_length": 0,
  "request_id": null,
  "inference_status": {
    "status": "unknown",
    "runtime_ms": 0,
    "cost": 0.0,
    "tokens_generated": 0,
    "tokens_input": 0
  }
}

```


DeepInfra supports custom voices.

## Create voice

The following creates a voice using the `curl` command.

```bash
curl -X POST "https://api.deepinfra.com/v1/elevenlabs/v1/voices/add" \
  -H "Content-Type: multipart/form-data" \
  -H "Authorization: Bearer $DEEPINFRA_TOKEN" \
  -F "audio=@hello.wav" \
  -F "name=John Doe" \
  -F "description=John Doe's voice"
```

which will return something similar to

```json
{
  "user_id": "gh:10000000", 
  "voice_id": "abcd1234abcd1234abcd",
  "name": "John Doe",
  "description": "John Doe's voice",
  "created_at": 1723851387,
  "updated_at": 1723851387
}
```


Currently we only support the creation of voices through the API. But there is an ongoing effort to support ElevenLabs python library.

```python
import requests

# Define the API endpoint
url = "https://api.deepinfra.com/v1/elevenlabs/v1/voices/add"

# Set the headers, including authorization
headers = {
    "Authorization": "Bearer YOUR_DEEPINFRA_TOKEN",
    "Content-Type": "multipart/form-data"
}

# Set the data, including the audio file, name, and description
data = {
    "name": "John Doe",
    "description": "John Doe's voice"
}

# Include the audio file in the request
files = {
    "audio": open("hello.wav", "rb")
}

# Send the POST request
response = requests.post(url, headers=headers, data=data, files=files)

# Check if the request was successful
if response.status_code == 200:
    # Parse the response JSON
    response_data = response.json()
    print("Voice created successfully!")
    print("Response:", response_data)
else:
    print("Failed to create voice.")
    print("Status Code:", response.status_code)
    print("Response:", response.text)
```

Currently we only support the creation of voices through the API. But there is an ongoing effort to support ElevenLabs JS library.

```javascript
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

// Define the API endpoint
const url = "https://api.deepinfra.com/v1/elevenlabs/v1/voices/add";

// Create a FormData instance
const formData = new FormData();

// Append the audio file, name, and description to the form data
formData.append('audio', fs.createReadStream('hello.wav'));
formData.append('name', 'John Doe');
formData.append('description', "John Doe's voice");

// Set the headers, including authorization and content type
const headers = {
    "Authorization": "Bearer YOUR_DEEPINFRA_TOKEN",
    ...formData.getHeaders()
};

// Send the POST request
axios.post(url, formData, { headers: headers })
    .then(response => {
        console.log("Voice created successfully!");
        console.log("Response:", response.data);
    })
    .catch(error => {
        console.error("Failed to create voice.");
        console.error("Status Code:", error.response.status);
        console.error("Response:", error.response.data);
    });
```

## Read voice

The following reads a voice using the `curl` command.

```bash
curl -X GET "https://api.deepinfra.com/v1/elevenlabs/v1/voices/abcd1234abcd1234abcd" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DEEPINFRA_TOKEN"
```

which will return something similar to

```json
{
  "user_id": "gh:10000000", 
  "voice_id": "abcd1234abcd1234abcd",
  "name": "John Doe",
  "description": "John Doe's voice",
  "created_at": 1723851387,
  "updated_at": 1723851387
}
```


## Read voice

The following reads a voice using a Python `requests` library.

```python
import requests

url = "https://api.deepinfra.com/v1/elevenlabs/v1/voices/abcd1234abcd1234abcd"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer YOUR_DEEPINFRA_TOKEN"
}

response = requests.get(url, headers=headers)

# Print the voice details
print(response.json())
```


## Read voice

The following reads a voice using JavaScript with the `fetch` API.

```javascript
const url = "https://api.deepinfra.com/v1/elevenlabs/v1/voices/abcd1234abcd1234abcd";
const headers = {
  "Content-Type": "application/json",
  "Authorization": "Bearer YOUR_DEEPINFRA_TOKEN"
};

fetch(url, { method: "GET", headers: headers })
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));
```

## Update voice

The following updates a voice using the `curl` command.

```bash
curl -X POST "https://api.deepinfra.com/v1/elevenlabs/v1/voices/abcd1234abcd1234abcd/edit" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DEEPINFRA_TOKEN" \
  -d '{"name": "Jane Doe", "description": "Jane Does voice"}'
```

which will return something similar to

```json
{
  "user_id": "gh:10000000", 
  "voice_id": "abcd1234abcd1234abcd",
  "name": "Jane Doe",
  "description": "Jane Doe's voice",
  "created_at": 1723851387,
  "updated_at": 1723851387
}
```


## Update voice

The following updates a voice using the `requests` library in Python.

```python
import requests

url = "https://api.deepinfra.com/v1/elevenlabs/v1/voices/abcd1234abcd1234abcd/edit"
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {your_deepinfra_token}"
}
data = {
    "name": "Jane Doe",
    "description": "Jane Doe's voice"
}

response = requests.post(url, headers=headers, json=data)

if response.status_code == 200:
    print(response.json())
else:
    print(f"Failed to update voice: {response.status_code}")
```


## Update voice

The following updates a voice using the `fetch` API in JavaScript.

```javascript
const url = "https://api.deepinfra.com/v1/elevenlabs/v1/voices/abcd1234abcd1234abcd/edit";
const headers = {
  "Content-Type": "application/json",
  "Authorization": `Bearer ${yourDeepinfraToken}`
};
const data = {
  name: "Jane Doe",
  description: "Jane Doe's voice"
};

fetch(url, {
  method: "POST",
  headers: headers,
  body: JSON.stringify(data)
})
.then(response => {
  if (response.ok) {
    return response.json();
  } else {
    throw new Error(`Failed to update voice: ${response.status}`);
  }
})
.then(data => console.log(data))
.catch(error => console.error(error));
```


## Delete voice

The following deletes a voice using the `curl` command.

```bash
curl -X DELETE "https://api.deepinfra.com/v1/elevenlabs/v1/voices/abcd1234abcd1234abcd" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DEEPINFRA_TOKEN"
```

which will return 200 OK status code.


## Delete voice

The following deletes a voice using the `requests` library in Python.

```python
import requests

url = "https://api.deepinfra.com/v1/elevenlabs/v1/voices/abcd1234abcd1234abcd"
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {your_deepinfra_token}"
}

response = requests.delete(url, headers=headers)

if response.status_code == 200:
    print("Voice deleted successfully.")
else:
    print(f"Failed to delete voice: {response.status_code}")
```


## Delete voice

The following deletes a voice using the `fetch` API in JavaScript.

```javascript
const url = "https://api.deepinfra.com/v1/elevenlabs/v1/voices/abcd1234abcd1234abcd";
const headers = {
  "Content-Type": "application/json",
  "Authorization": `Bearer ${yourDeepinfraToken}`
};

fetch(url, {
  method: "DELETE",
  headers: headers
})
.then(response => {
  if (response.ok) {
    console.log("Voice deleted successfully.");
  } else {
    throw new Error(`Failed to delete voice: ${response.status}`);
  }
})
.catch(error => console.error(error));
```


## List voices
The following lists voices using the `curl` command.

```bash
curl -X GET "https://api.deepinfra.com/v1/elevenlabs/v1/voices" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DEEPINFRA_TOKEN" \
```

which will return something similar to

```json
{
  "voices": [
    {
      "user_id": "gh:10000000", 
      "voice_id": "abcd1234abcd1234abcd",
      "name": "John Doe",
      "description": "John Doe's voice",
      "created_at": 1723851387,
      "updated_at": 1723851387
    },
    {
      "user_id": "gh:10000000",
      "voice_id":"abcd1234abcd1234abc1",
      "name": "Jane Doe",
      "description": "Jane Doe's voice",
      "created_at": 1723680057,
      "updated_at": 1723680057
    }
  ]
}
```


## List voices

The following lists voices using the `requests` library in Python.

```python
import requests

url = "https://api.deepinfra.com/v1/elevenlabs/v1/voices"
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {your_deepinfra_token}"
}

response = requests.get(url, headers=headers)

if response.status_code == 200:
    voices = response.json()
    print(voices)
else:
    print(f"Failed to list voices: {response.status_code}")
```


## List voices

The following lists voices using the `fetch` API in JavaScript.

```javascript
const url = "https://api.deepinfra.com/v1/elevenlabs/v1/voices";
const headers = {
  "Content-Type": "application/json",
  "Authorization": `Bearer ${yourDeepinfraToken}`
};

fetch(url, {
  method: "GET",
  headers: headers
})
.then(response => {
  if (response.ok) {
    return response.json();
  } else {
    throw new Error(`Failed to list voices: ${response.status}`);
  }
})
.then(data => console.log(data))
.catch(error => console.error(error));
```


text

output_format

Preset voice name to use for the speech. Either preset_voice or voice_id should be provided

preset_voice

language_code

Voice ID to use for the speech. If set value of preset_voice will be ignored. Either preset_voice or voice_id should be provided

voice_id

speed

Whether to stream the audio, by default it will be false. 

stream

The webhook to call when inference is done, by default you will get the output in the response of your inference request