Bulk Send

This request is used to send SMS messages in real-time or scheduled.

URL

POST https://api.smspartner.fr/v1/send

The platform does not send marketing SMS between 8 PM and 8 AM on weekdays, as well as on Sundays and public holidays (legal restriction). If a message is sent during that time, it will be on hold until the next working day at 8 AM. Not sending marketing SMS? Contact us to disable this restriction: [email protected]

Required Parameters

Name

Value

apiKey

Your API key

SMSList

phoneNumber → Recipient's phone number. Limit per request is 500 numbers. Must be:

In national format (06xxxxxxxx) or international (+336xxxxxxxx) for French numbers
In international format (+496xxxxxxxx) for non-French numbers

message → SMS content. 160 characters max per SMS (additional SMS units will be charged per 153-character segment beyond that).

Line break → :br: Note: Line break counts as two characters.

€ symbol → :euro:

The character ” must be escaped (\”) for the message to be valid. Otherwise, a 400 error will be returned.

Some Special Characters may be replaced during sending. Please review them.

Optional Parameters

Name

Value

sender

Sender name. If left empty, the SMS will be sent using a short operator code (e.g., 36xxx).

Sender name must be between 3 and 11 characters and must not contain special characters. Some mobile phones may not display spaces properly.

tag

String (max 20 characters, no spaces, lowercase only)

scheduledDeliveryDate

dd/mm/YYYY (for scheduled sending)

time

Format: 0–24 (hour of delivery)

If scheduledDeliveryDate is set, this parameter is required

minute

Format: 0–55 (5-minute intervals)

If scheduledDeliveryDate is set, this parameter is required

isStopSms

1 to add the STOP mention at the end of the SMS (mandatory and automatic for marketing SMS)

isUnicode

If 1: Enables Unicode mode, max characters per SMS will be 70.

Note: Unicode SMS must be enabled on your account by an administrator. Please contact technical support to activate this feature.

> View full list of emojis

sandbox

1 for Sandbox Mode

No SMS will be sent and no credit will be charged. These SMS will be automatically deleted from your logs every day.

_format

json or xml

Requests

<?php
        // Prepare data for POST request
        $fields = array(
            'apiKey'=> 'YOUR API KEY',
            'sender' => 'mycompany',
            'scheduledDeliveryDate'=> '21/10/2014',
            'time'=> 9,
            'minute'=> 0,
            'SMSList'=> array(
                array(
                    'phoneNumber'=> '06xxxxxxx1',
                    'message'=> 'msg 0'
                ),
                array(
                    'phoneNumber'=> '06xxxxxxx2',
                    'message'=> 'msg 1'
                )
 
            )
        );
 
 
        $curl = curl_init();
        curl_setopt($curl, CURLOPT_URL,'https://api.smspartner.fr/v1/bulk-send');
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($curl, CURLOPT_TIMEOUT, 10);
        curl_setopt($curl, CURLOPT_POST, 1);
        curl_setopt($curl, CURLOPT_POSTFIELDS,json_encode($fields));
 
        $result = curl_exec($curl);
        curl_close($curl);
 
        // Process your response here
        echo $result;
?>

Imports System.IO
Imports System.Net
 
Module Module1
 
  Sub Main()
 
    Dim base_url As String = "http://api.smspartner.fr/v1/"
    Dim apiKey As String = "VOTRE_APIKEY"
 
    #send sms
    url = base_url & "bulk-send"
    #note : utiliser une librairie JSON en production, par exemple :
    #https//www.nuget.org/packages/Newtonsoft.Json/
    Dim parameters As String = String.Format(
        "{{""apiKey"":""{0}"",""sender"":""{1}"",""SMSList"":""{2}""}}",
        apiKey,
        "mycompany",
        {{ ""phoneNumber"":"06xxxxxxx1",""message"":"msg1"},{ ""phoneNumber"":"06xxxxxxx2",""message"":"msg2"}}
        )
    Console.Write(parameters)
    apiRequest("POST", url, parameters)
 
  End Sub
 
  Function apiRequest(method As String, url As String, parameters As String) As String
 
    Dim request As HttpWebRequest
    request = WebRequest.Create(url)
    request.Method = method
    request.Timeout = 10000   # timeout in ms
    request.ContentType = "application/json; charset=utf-8"
    request.ContentLength = 0
 
    #set POST data
    If Not String.IsNullOrEmpty(parameters) Then
      request.ContentLength = parameters.Length
      Using reqStream As StreamWriter = New StreamWriter(request.GetRequestStream())
        reqStream.Write(parameters)
      End Using
    End If
 
    #get response
    Dim returnValue As String = Nothing
    Using response As HttpWebResponse = request.GetResponse()
      If response.StatusCode = HttpStatusCode.OK Then
        Using resStream = response.GetResponseStream()
          If resStream IsNot Nothing Then
            Using reader As New StreamReader(resStream)
              returnValue = reader.ReadToEnd()
            End Using
          End If
        End Using
      End If
    End Using
    apiRequest = returnValue
 
  End Function
 
End Module

# std
import logging
import json
from collections import OrderedDict
 
# 3p
import requests
 
API_KEY = "MY API KEY"
URL = "https://api.smspartner.fr/v1"
 
class SMSPartner():
    def send_sms(self,phone_numbers, msg, sender = "SMSPartner"):
		#sender = "DEMOSMS"
		print(phone_numbers)
 
 
		data = {"apiKey":APIKEY,"sender":sender,"SMSList":[{"phoneNumber":"06xxxxxxx1","message":"msg1"},{"phoneNumber":"06xxxxxxx2","message":"msg2"}]}
 
 
		url = URL + "/bulk-send"
		r = requests.post(url, data=json.dumps(data), verify=False)
 
		r_json = r.json()
		if r_json.get("success") == True:
			print(r_json)
			status = True
		else:
			print("SMS msg {} not delivered to {}".format(msg, phone_numbers))
			status = False
		return status

const https = require('https');

// Remplacez par votre clé API
const apiKey = 'VOTRE_CLÉ_API';

// Objet JSON qui contient les informations nécessaires pour envoyer les SMS en lots
const data = JSON.stringify({
    apiKey: apiKey,
    sender: 'mycompany',
    scheduledDeliveryDate: '21/10/2014',
    time: 9,
    minute: 0,
    SMSList: [
        {
            phoneNumber: '06xxxxxxx1',
            message: 'msg 0',
        },
        {
            phoneNumber: '06xxxxxxx2',
            message: 'msg 1',
        },
    ],
});

// Définir les options pour la requête HTTP POST vers l'API SMS Partner
const options = {
    hostname: 'api.smspartner.fr',
    port: 443,
    path: '/v1/bulk-send',
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'Content-Length': data.length,
        'cache-control': 'no-cache',
    },
};

// Demande HTTP POST avec les options et les données définies précédemment
const req = https.request(options, (res) => {
    console.log(`statusCode: ${res.statusCode}`);

    // Afficher les données de réponse de l'API sur la sortie standard
    res.on('data', (d) => {
        process.stdout.write(d);
    });
});

// Affichage en cas d'erreur lors de l'exécution de la requête HTTP POST
req.on('error', (error) => {
    console.error(error);
});

// Envoyer les données de l'objet 'data' à la demande
req.write(data);
// Terminer la demande HTTP POST
req.end();

import java.net.HttpURLConnection;
import java.net.URL;
import java.io.OutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.stream.Collectors;
import org.json.JSONArray;
import org.json.JSONObject;

public class SMSparLots {
    public static void main(String[] args) {
        try {
            // Création de l'objet URL avec l'adresse de l'API SMS
            URL url = new URL("https://api.smspartner.fr/v1/bulk-send");
            // Ouverture de la connexion HTTP avec l'API
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST");
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setRequestProperty("cache-control", "no-cache");
            conn.setDoOutput(true);

            // Création de l'objet JSON contenant les paramètres des SMS à envoyer en lot
            JSONObject json = new JSONObject();
            json.put("apiKey", "VOTRE_API_KEY"); // Remplacez par votre clé API
            json.put("sender", "mycompany");
            json.put("scheduledDeliveryDate", "21/10/2014");
            json.put("time", 9);
            json.put("minute", 0);

            JSONArray SMSList = new JSONArray();
            JSONObject sms1 = new JSONObject();
            sms1.put("phoneNumber", "06xxxxxxx1");
            sms1.put("message", "msg 0");
            SMSList.put(sms1);

            JSONObject sms2 = new JSONObject();
            sms2.put("phoneNumber", "06xxxxxxx2");
            sms2.put("message", "msg 1");
            SMSList.put(sms2);

            json.put("SMSList", SMSList);

            // Écriture des données JSON dans le corps de la requête HTTP
            OutputStream os = conn.getOutputStream();
            os.write(json.toString().getBytes());
            os.flush();

            // Lecture de la réponse de l'API
            BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            String response = br.lines().collect(Collectors.joining());
            System.out.println(response);

            // Fermeture de la connexion HTTP
            conn.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import SwiftUI

// Cette requête est utilisée pour envoyer des SMS par lot de 500 en temps réel ou en différé
struct SMSParLotsView: View {
    var body: some View {
        // Un bouton qui appelle la fonction sendSMSParLots() lorsqu'il est pressé
        Button(action: {
            sendSMSParLots()
        }) {
            Text("Send Bulk SMS")
                .font(.system(size: 20))
                .foregroundColor(.white)
                .frame(minWidth: 0, maxWidth: .infinity)
                .padding()
                .background(LinearGradient(gradient: Gradient(colors: [Color.blue, Color.blue.opacity(0.8)]), startPoint: .top, endPoint: .bottom))
                .cornerRadius(10)
                .padding(.horizontal)
        }
    }
    

    func sendSMSParLots() {
        // Liste des SMS à envoyer
        let smsList: [[String: String]] = [
            [
                "phoneNumber": "06XXXXXXXX", // Numéro de téléphone du destinataire
                "message": "msg 0 en temps réel" // Message à envoyer
            ],
            [
                "phoneNumber": "06XXXXXXXX", // Un autre numéro de téléphone
                "message": "msg 1 en temps réel" // Un autre message
            ]
        ]

        // Données à envoyer à l'API
        let data: [String: Any] = [
            "apiKey": "XXXXXXXXXXXX YOUR API KEY XXXXXXXXXXXXX", // Votre clé API
            "sender": "mycompany", // L'expéditeur du SMS
            // Ces 3 lignes permettent de programmer un envoi différé.
            //"scheduledDeliveryDate": "12/05/2023", // Date de livraison prévue
            //"time": 9, // Heure de livraison
            //"minute": 0, // Minute de livraison
            "SMSList": smsList // La liste des SMS à envoyer
        ]

        // Conversion des données en JSON
        guard let jsonData = try? JSONSerialization.data(withJSONObject: data, options: []) else {
            fatalError("Error converting data to JSON.")
        }

        // Création de la requête HTTP
        let url = URL(string: "https://api.smspartner.fr/v1/bulk-send")! // URL de l'API
        var request = URLRequest(url: url)
        request.httpMethod = "POST" // Méthode HTTP
        request.httpBody = jsonData // Corps de la requête
        request.addValue("application/json", forHTTPHeaderField: "Content-Type") // Type de contenu
        request.addValue("\(jsonData.count)", forHTTPHeaderField: "Content-Length") // Longueur du contenu
        request.addValue("no-cache", forHTTPHeaderField: "cache-control") // Contrôle du cache

        // Envoi de la requête HTTP
        let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
            // Vérification de la réponse HTTP
            guard let httpResponse = response as? HTTPURLResponse else {
                fatalError("Error: Invalid HTTP response.")
            }
            print("statusCode: \(httpResponse.statusCode)") // Impression du code d'état HTTP

            // Gestion des erreurs éventuelles
            if let error = error {
                print("Error: \(error.localizedDescription)")
            }

            // Impression de la réponse de l'API
            if let data = data {
                if let responseString = String(data: data, encoding: .utf8) {
                    print("Response: \(responseString)")
                }
            }
        }
        task.resume()
    }
}
// Un aperçu de la vue
struct BulkSMSView_Previews: PreviewProvider {
    static var previews: some View {
        SMSParLotsView()
    }
}

package main

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

func main() {
	apiKey := "VOTRE CLE API"
	sender := "monentreprise"
	scheduledDeliveryDate := "21/10/2014"
	time := 9
	minute := 0

	// Construire les données JSON pour la requête POST
	data := map[string]interface{}{
		"apiKey":               apiKey,
		"sender":               sender,
		"scheduledDeliveryDate": scheduledDeliveryDate,
		"time":                 time,
		"minute":               minute,
		"SMSList": []map[string]string{
			{"phoneNumber": "06xxxxxxx1", "message": "msg 0"},
			{"phoneNumber": "06xxxxxxx2", "message": "msg 1"},
		},
	}

	// Convertir les données en JSON
	jsonData, err := json.Marshal(data)
	if err != nil {
		fmt.Println("Erreur lors de la conversion en JSON:", err)
		return
	}

	// Effectuer la requête POST
	url := "https://api.smspartner.fr/v1/bulk-send"
	resp, err := http.Post(url, "application/json", bytes.NewBuffer(jsonData))
	if err != nil {
		fmt.Println("Erreur lors de l'envoi de la requête:", err)
		return
	}
	defer resp.Body.Close()

	// Traiter la réponse
	if resp.StatusCode == http.StatusOK {
		body := new(bytes.Buffer)
		_, err := body.ReadFrom(resp.Body)
		if err != nil {
			fmt.Println("Erreur lors de la lecture de la réponse:", err)
			return
		}
		fmt.Println(body.String())
	} else {
		fmt.Println("La requête POST a échoué. Code de réponse:", resp.StatusCode)
	}
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

class Program
{
    private static readonly HttpClient client = new HttpClient();

    static async Task Main(string[] args)
    {
        var request = new
        {
            apiKey = "YOUR_API_KEY",
            sender = "mycompany",
            scheduledDeliveryDate = "21/10/2014",
            time = 9,
            minute = 0,
            SMSList = new[]
            {
                new
                {
                    phoneNumber = "06xxxxxxx1",
                    message = "msg 0"
                },
                new
                {
                    phoneNumber = "06xxxxxxx2",
                    message = "msg 1"
                }
            }
        };

        var content = new StringContent(
            JsonConvert.SerializeObject(request),
            Encoding.UTF8,
            "application/json");

        HttpResponseMessage response = await client.PostAsync("https://api.smspartner.fr/v1/bulk-send", content);

        if (response.IsSuccessStatusCode)
        {
            var result = await response.Content.ReadAsStringAsync();
            Console.WriteLine(result);
        }
        else
        {
            Console.WriteLine("POST request failed with status code: " + response.StatusCode);
        }
    }
}

Response

{
    "success": true,
    "code": 200,
    "message_id": "xxxxxx",
    "currency": "EUR",
    "cost": 0.076,
    "nbSMS": 2,
    "SMSResponse_List": [
        {
            "success": true,
            "code": 200,
            "nbSms": 1,
            "cost": 0.038,
            "phoneNumber": "+336xxxxxxx1"
        },
        {
            "success": true,
            "code": 200,
            "nbSms": 1,
            "cost": 0.038,
            "phoneNumber": "+336xxxxxxx2"
        }
    ]
}

<?xml version='1.0' encoding='UTF-8'?>
<result>
    <entry>true</entry>
    <entry>200</entry>
    <entry>xxxxxx</entry>
    <entry>
        <![CDATA[EUR]]>
    </entry>
    <entry>0.076</entry>
    <entry>2</entry>
    <entry>
        <entry>
            <entry>true</entry>
            <entry>200</entry>
            <entry>1</entry>
            <entry>0.038</entry>
            <entry>
                <![CDATA[+336xxxxxxx1]]>
            </entry>
        </entry>
        <entry>
            <entry>true</entry>
            <entry>200</entry>
            <entry>1</entry>
            <entry>0.038</entry>
            <entry>
                <![CDATA[+336xxxxxxx2]]>
            </entry>
        </entry>
    </entry>
</result>

Errors

{
    "success": false,
    "code": 9,
    "error": [
        {
            "elementId": "children[message].data",
            "message": "Message is required"
        },
        {
            "elementId": "children[phoneNumber].data",
            "message": "Phone number is not valid (922264)"
        },
        {
            "elementId": "children[sender].data",
            "message": "Sender cannot exceed 11 characters"
        },
        {
            "elementId": "children[scheduledDeliveryDate].data",
            "message": "Date (21/11/2014 :) is earlier than the current date."
        },
        {
            "elementId": "children[minute].data",
            "message": "Minute is required"
        },
        {
            "elementId": "children[time].data",
            "message": "Hour is required"
        }
    ]
}

<?xml version='1.0' encoding='UTF-8'?>
<result>
    <entry>false</entry>
    <entry>9</entry>
    <entry>
        <entry>
            <entry>children[message].data</entry>
            <entry>Message is required</entry>
        </entry>
        <entry>
            <entry>children[phoneNumber].data</entry>
            <entry>This phone number is not valid (922264)</entry>
        </entry>
        <entry>
            <entry>children[sender].data</entry>
            <entry>Sender cannot exceed 11 characters</entry>
        </entry>
        <entry>
            <entry>children[scheduledDeliveryDate].data</entry>
            <entry>Date (21/11/2014 :) is earlier than the current date. To send it now, select [Immediate send]</entry>
        </entry>
        <entry>
            <entry>children[minute].data</entry>
            <entry>Minute is required</entry>
        </entry>
        <entry>
            <entry>children[time].data</entry>
            <entry>Hour is required</entry>
        </entry>
    </entry>
</result>

Error Codes

Response Code

Description

API Key is required

Phone number is required

At least one constraint was not met during sending: - Sender cannot exceed 11 characters - Invalid phone number - If scheduledDeliveryDate is set: The date (dd/mm/yyyy) is earlier than the current date. Minute is required. Hour is required.

Invalid API Key

Insufficient credits

PreviousSingle Send NextSend by Long Number

Last updated 8 months ago