# Envoyer un SMS Vocal

## URL

<mark style="color:green;">`POST`</mark> `https://api.voicepartner.fr/v1/tts/send`

{% hint style="warning" %}
Limite : 2000 requêtes par heure
{% endhint %}

#### **Paramètres obligatoires**

<table data-full-width="false"><thead><tr><th width="232">Nom</th><th>Valeur</th></tr></thead><tbody><tr><td><code>apiKey</code></td><td><a href="https://my.voicepartner.fr/app/api">Votre clé API</a></td></tr><tr><td><code>text</code></td><td>Texte du message vocal. <a href="#pause-entre-les-mots">Une pause entre les mots est possible</a>.</td></tr><tr><td><code>tokenAudio</code></td><td>Identifiant du fichier audio, le paramètre "text" ne sera pas pris en compte</td></tr><tr><td><code>lang</code></td><td>La langue dans laquelle le message est envoyé</td></tr><tr><td><code>phoneNumbers</code></td><td><p>Numéros de téléphone mobile des destinataires.<br>Pour l’envoi de plusieurs SMS les numéros doivent être séparés par des virgules.<br>Ils peuvent être :</p><ul><li>au format national (06xxxxxxxx) ou international (+336xxxxxxxx), pour des numéros français.</li></ul></td></tr></tbody></table>

#### **Paramètres optionnels**

<table><thead><tr><th width="262">Nom</th><th>Valeur</th></tr></thead><tbody><tr><td><code>speechRate</code></td><td>La vitesse de reproduction de la parole dans le message. Efficace uniquement lorsque vous utilisez du texte. La plage prise en charge va de 0.5 (parole ralentie) à 2 (accélération de la parole). Les valeurs inférieures à 0.5 seront remplacées par 0.5 et les valeurs supérieures à 2 seront remplacées par 2. La vitesse par défaut est 1.</td></tr><tr><td><code>notifyUrl</code></td><td>Url de retour du statut du SMS vocal envoyé en POST au format JSON</td></tr><tr><td><code>scheduledDate</code></td><td>Date d’envoi du message, au format <code>YYYY-mm-dd H:m:00</code> (ex: <code>2021-02-02 14:15:00</code>). A définir uniquement si vous souhaitez que les SMS soient envoyés en différé.</td></tr><tr><td><code>audioComplementary</code></td><td>Identifiant du fichier audio qui sera déposé si le destinataire ne décroche pas.</td></tr></tbody></table>

#### Pause entre les mots

{% hint style="info" %}
Il est possible d’ajouter des pauses entre les mots et d’allonger la durée du message vocal en utilisant la virgule «,».\
Par exemple, si vous souhaitez avoir une pause de 3 secondes après chaque mot, le paramètre text devrait alors ressembler à ceci: «un ,,,,,, deux ,,,,,, trois ,,,,,,». Chaque virgule crée une **pause de 0,5 seconde**.
{% endhint %}

#### Requêtes

{% tabs %}
{% tab title="PHP" %}

```php
<?php

// Activer l'affichage des erreurs pour le débogage
ini_set('display_errors', 1);
ini_set('display_startup_errors', 1);
error_reporting(E_ALL);

// L'URL de l'API pour envoyer le message vocal
$url = 'http://api.voicepartner.fr/v1/tts/send';

// Les données à envoyer en JSON
$data = [
    'apiKey' => 'YOUR_API_KEY',         // Remplacez par votre clé API réelle
    'phoneNumbers' => '06XXXXXXXX',     // Remplacez par le(s) numéro(s) de téléphone réel(s)
    'text' => 'Mon premier test',       // Remplacez par le texte que vous souhaitez convertir en parole
    // 'speed' => '1',                  // Optionnel: Vitesse de la parole
    // 'notifyUrl' => 'http://...',     // Optionnel: URL de notification
    // 'scheduledDate' => 'YYYY-mm-dd H:i:00', // Optionnel: Date prévue pour l'envoi
];

// Encodage des données en JSON
$data_json = json_encode($data);

// Initialisation de cURL
$curl = curl_init($url);

// Configuration des options de cURL pour envoyer du JSON
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POST, true);
curl_setopt($curl, CURLOPT_POSTFIELDS, $data_json);
curl_setopt($curl, CURLOPT_HTTPHEADER, array(
    'Content-Type: application/json',
    'Cache-Control: no-cache'
));

// Exécution de la requête cURL et enregistrement de la réponse
$response = curl_exec($curl);

// Vérification s'il y a eu des erreurs pendant l'exécution de la requête
if (curl_errno($curl)) {
    echo 'Erreur cURL : ' . curl_error($curl);
} else {
    // Affichage de la réponse
    echo 'Réponse : ' . $response;
}

// Fermeture de la session cURL
curl_close($curl);
```

{% endtab %}

{% tab title="VB.net" %}

```vbnet
Imports System.Net.Http
Imports System.Threading.Tasks
Imports Newtonsoft.Json
Imports System.Text

Public Class EnvoyerSmsVocal
    Private Const Url As String = "http://api.voicepartner.fr/v1/tts/send"

    Public Shared Async Function SendSmsVocalAsync() As Task
        Using client As New HttpClient()
            ' Remplacez ces valeurs par les vôtres
            Dim apiKey As String = "YOUR_API_KEY"
            Dim phoneNumbers As String = "06XXXXXXXX"
            Dim text As String = "Mon premier test"
            ' ... autres paramètres si nécessaire

            Dim data = New With {
                .apiKey = apiKey,
                .phoneNumbers = phoneNumbers,
                .text = text
            }

            Dim jsonContent = JsonConvert.SerializeObject(data)
            Using content As New StringContent(jsonContent, Encoding.UTF8, "application/json")
                Try
                    Dim response = Await client.PostAsync(Url, content)
                    Dim responseContent = Await response.Content.ReadAsStringAsync()

                    If response.IsSuccessStatusCode Then
                        Console.WriteLine(responseContent)
                    Else
                        Console.WriteLine($"Erreur lors de la requête: {response.StatusCode}")
                        Console.WriteLine($"Contenu: {responseContent}")
                    End If
                Catch ex As Exception
                    Console.WriteLine($"Exception: {ex.Message}")
                End Try
            End Using
        End Using
    End Function
End Class
```

{% endtab %}

{% tab title="Python" %}

```python
import requests
import json

# Activer l'affichage des erreurs pour le débogage
# En Python, les erreurs sont affichées par défaut lorsqu'elles se produisent.

# L'URL de l'API pour envoyer le message vocal
url = 'http://api.voicepartner.fr/v1/tts/send'

# Les données à envoyer en JSON
data = {
    'apiKey': 'YOUR_API_KEY',  # Remplacez par votre clé API réelle
    'phoneNumbers': '06XXXXXXXX',  # Remplacez par le(s) numéro(s) de téléphone réel(s)
    'text': 'Mon premier test',  # Remplacez par le texte que vous souhaitez convertir en parole
    # 'speed': '1',  # Optionnel: Vitesse de la parole
    # 'notifyUrl': 'http://...',  # Optionnel: URL de notification
    # 'scheduledDate': 'YYYY-mm-dd H:i:00',  # Optionnel: Date prévue pour l'envoi
}

# Encodage des données en JSON
data_json = json.dumps(data)

# Configuration des en-têtes HTTP
headers = {
    'Content-Type': 'application/json',
    'Cache-Control': 'no-cache'
}

# Exécution de la requête POST avec les données JSON
response = requests.post(url, data=data_json, headers=headers)

# Vérification s'il y a eu des erreurs pendant l'exécution de la requête
if response.status_code != 200:
    print(f'Erreur cURL : {response.status_code}')
else:
    # Affichage de la réponse
    print(f'Réponse : {response.text}')
```

{% endtab %}

{% tab title="cURL" %}

```
curl -X POST 'http://api.voicepartner.fr/v1/tts/send' \
     -H 'Content-Type: application/json' \
     -H 'Cache-Control: no-cache' \
     -d '{
          "apiKey": "YOUR_API_KEY",
          "phoneNumbers": "06XXXXXXXX",
          "text": "Mon premier test"
          // "speed": "1", // Optionnel
          // "notifyUrl": "http://...", // Optionnel
          // "scheduledDate": "YYYY-mm-dd H:i:00" // Optionnel
         }'
```

{% endtab %}

{% tab title="Nodejs" %}

```javascript
const axios = require('axios');

// L'URL de l'API pour envoyer le message vocal
const url = 'http://api.voicepartner.fr/v1/tts/send';

// Les données à envoyer en JSON
const data = {
    apiKey: 'YOUR_API_KEY',
    phoneNumbers: '06XXXXXXXX',
    text: 'Mon premier test'
    // ... autres paramètres si nécessaire
};

axios.post(url, data)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error('Erreur lors de la requête:', error);
    });
```

{% endtab %}

{% tab title="JAVA" %}

```java
package com.example.API;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpResponse.BodyHandlers;

public class EnvoyerSmsVocal {
    public static void main(String[] args) {
        // L'URL de l'API
        String apiUrl = "https://api.voicepartner.fr/v1/tts/send";

        // Les données à envoyer en JSON
        String json = """
                {
                    "apiKey": "YOUR_API_KEY",
                    "phoneNumbers": "06XXXXXXXX",
                    "text": "Mon premier test",
                    "speechRate": "1",
                    "notifyUrl": "http://example.com/notify",
                }
                """;

        // Créer une instance de HttpClient
        HttpClient client = HttpClient.newHttpClient();

        // Construire la requête
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(apiUrl))
                .header("Content-Type", "application/json")
                .POST(BodyPublishers.ofString(json))
                .build();

        // Envoyer la requête de manière asynchrone
        client.sendAsync(request, BodyHandlers.ofString())
                .thenApply(response -> response) // Retourner l'objet de réponse entier
                .thenAccept(response -> {
                    // Maintenant, vous pouvez appeler les méthodes sur l'objet HttpResponse
                    System.out.println("Status Code: " + response.statusCode());
                    System.out.println("Response: " + response.body());
                })
                .exceptionally(e -> {
                    e.printStackTrace(); // Affiche le stack trace en cas d'erreur
                    return null;
                })
                .join(); // Attendre la fin de l'opération asynchrone
    }
}
```

{% endtab %}

{% tab title="GO" %}

```go
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
)

type SmsData struct {
	ApiKey        string   `json:"apiKey"`
	Text          string   `json:"text"`
	PhoneNumbers  string   `json:"phoneNumbers"`
	Lang          *string  `json:"lang,omitempty"`          // Optional: Language of the SMS
	SpeechRate    *float64 `json:"speechRate,omitempty"`    // Optional: Rate of the speech
	NotifyUrl     *string  `json:"notifyUrl,omitempty"`     // Optional: Notification URL
	ScheduledDate *string  `json:"scheduledDate,omitempty"` // Optional: Scheduled date and time
}

func main() {
	url := "http://api.voicepartner.fr/v1/tts/send"
	//lang := "fr"
	//speechRate := 1.0
	//notifyUrl := "https://yourdomain.com/notify"
	//scheduledDate := "2024-04-12 14:30:00" // Example format: 'yyyy-MM-dd HH:mm:ss'

	data := SmsData{
		ApiKey:       "YOUR_API_KEY",
		Text:         "Votre texte ici",
		PhoneNumbers: "06XXXXXXXX",
		//Lang:         &lang,                  // Uncomment to use
		//SpeechRate:   &speechRate,            // Uncomment to use
		//NotifyUrl:    &notifyUrl,             // Uncomment to use
		//ScheduledDate: &scheduledDate,        // Uncomment to use
	}

	payloadBytes, err := json.Marshal(data)
	if err != nil {
		fmt.Printf("Error: %s\n", err.Error())
		return
	}
	body := bytes.NewReader(payloadBytes)

	req, err := http.NewRequest("POST", url, body)
	if err != nil {
		fmt.Printf("Error: %s\n", err.Error())
		return
	}
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		fmt.Printf("Error: %s\n", err.Error())
		return
	}
	defer resp.Body.Close()

	respBody, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Printf("Error: %s\n", err.Error())
		return
	}

	fmt.Printf("Response: %s\n", string(respBody))
}
```

{% endtab %}

{% tab title="C#" %}

```csharp
using Newtonsoft.Json;
using System.Text;

public class EnvoyerSmsVocal
{
    public static async Task Main()
    {
        var url = "http://api.voicepartner.fr/v1/tts/send";
        //var scheduledDate = "2024-04-12 10:30:00"; // Format 'yyyy-MM-dd HH:mm:ss'

        var data = new
        {
            apiKey = "YOUR_API_KEY",
            text = "Votre texte ici",
            phoneNumbers = "06XXXXXXXX",
            // Ajoutez d'autres paramètres optionnels si nécessaire
            //speechRate = 1.0, // La vitesse par défaut est 1
            //notifyUrl = "https://yourdomain.com/notify",
            //scheduledDate
        };

        using (var client = new HttpClient())
        {
            try
            {
                var json = JsonConvert.SerializeObject(data);
                var content = new StringContent(json, Encoding.UTF8, "application/json");
                var response = await client.PostAsync(url, content);
                var responseContent = await response.Content.ReadAsStringAsync();
                Console.WriteLine("Response: " + responseContent);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error: " + ex.Message);
            }
        }
    }
}
```

{% endtab %}
{% endtabs %}

#### **Réponse**

{% tabs %}
{% tab title="json" %}

```json
{
    "success": true,
    "campaignId": "Ff1tbu0lax",
    "cost": xxx,
    "currency": "EUR",
    "nbSms": 1,
    "lang": "en",
    "duration": 6.3,
    "detail": {
        "33": {
            "nbSms": 1,
            "cost_unity": xxx,
            "cost": xxx,
            "country_code": "fr",
            "duration": 6.3
        }
    }
}
```

{% endtab %}
{% endtabs %}


---

# Agent Instructions: 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:

```
GET https://www.docpartner.dev/api/voice-partner/envoyer-un-sms-vocal.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.