Documentation API

import requests
import json

API_KEY = "VOTRE_CLE_API"
BASE_URL = "https://app.1smsafrica.com/api/v3"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json"
}

# Envoyer un SMS
def send_sms(recipient, sender_id, message):
    data = {
        "recipient": recipient,
        "sender_id": sender_id,
        "message": message
    }
    
    response = requests.post(
        f"{BASE_URL}/sms/send",
        headers=headers,
        json=data
    )
    
    return response.json()

# Vérifier le solde
def check_balance():
    response = requests.get(
        f"{BASE_URL}/balance",
        headers=headers
    )
    return response.json()

# Exemple d'utilisation
if __name__ == "__main__":
    # Envoyer un SMS
    result = send_sms(
        recipient="2250700000000",
        sender_id="MonEntreprise",
        message="Bonjour! Votre code est: 123456"
    )
    
    if result["status"] == "success":
        print(f"SMS envoyé! ID: {result['data']['uid']}")
    else:
        print(f"Erreur: {result['message']}")
    
    # Vérifier le solde
    balance = check_balance()
    print(f"Solde: {balance['data']['balance']} {balance['data']['currency']}")

const axios = require('axios');

const API_KEY = 'VOTRE_CLE_API';
const BASE_URL = 'https://app.1smsafrica.com/api/v3';

// Configuration axios
const api = axios.create({
    baseURL: BASE_URL,
    headers: {
        'Authorization': \`Bearer ${API_KEY}\`,
        'Content-Type': 'application/json',
        'Accept': 'application/json'
    }
});

// Envoyer un SMS
async function sendSMS(recipient, senderId, message) {
    try {
        const response = await api.post('/sms/send', {
            recipient,
            sender_id: senderId,
            message
        });
        
        return response.data;
    } catch (error) {
        throw error.response?.data || error.message;
    }
}

// Vérifier le solde
async function checkBalance() {
    try {
        const response = await api.get('/balance');
        return response.data;
    } catch (error) {
        throw error.response?.data || error.message;
    }
}

// Exemple d'utilisation
(async () => {
    try {
        const result = await sendSMS('2250700000000', 'MonEntreprise', 'Bonjour!');
        console.log('SMS envoyé! ID:', result.data.uid);
        
        const balance = await checkBalance();
        console.log(\`Solde: ${balance.data.balance} ${balance.data.currency}\`);
    } catch (error) {
        console.error('Erreur:', error);
    }
})();

const API_KEY = 'VOTRE_CLE_API';
const BASE_URL = 'https://app.1smsafrica.com/api/v3';

async function sendSMS(recipient, senderId, message) {
    const response = await fetch(\`${BASE_URL}/sms/send\`, {
        method: 'POST',
        headers: {
            'Authorization': \`Bearer ${API_KEY}\`,
            'Content-Type': 'application/json',
            'Accept': 'application/json'
        },
        body: JSON.stringify({
            recipient,
            sender_id: senderId,
            message
        })
    });
    
    return response.json();
}

// Utilisation
sendSMS('2250700000000', 'MonEntreprise', 'Votre code: 123456')
    .then(result => console.log('Résultat:', result))
    .catch(error => console.error('Erreur:', error));

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

public class SMSClient {
    private static final String API_KEY = "VOTRE_CLE_API";
    private static final String BASE_URL = "https://app.1smsafrica.com/api/v3";
    
    private final HttpClient client;
    
    public SMSClient() {
        this.client = HttpClient.newHttpClient();
    }
    
    public String sendSMS(String recipient, String senderId, String message) throws Exception {
        String json = String.format(
            "{\"recipient\":\"%s\",\"sender_id\":\"%s\",\"message\":\"%s\"}",
            recipient, senderId, message
        );
        
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/sms/send"))
            .header("Authorization", "Bearer " + API_KEY)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(json))
            .build();
        
        HttpResponse<String> response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());
        
        return response.body();
    }
    
    public static void main(String[] args) {
        try {
            SMSClient smsClient = new SMSClient();
            String result = smsClient.sendSMS("2250700000000", "MonEntreprise", "Bonjour!");
            System.out.println("Résultat: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import okhttp3.*;
import org.json.JSONObject;

public class SMSClientOkHttp {
    private static final String API_KEY = "VOTRE_CLE_API";
    private static final String BASE_URL = "https://app.1smsafrica.com/api/v3";
    private static final MediaType JSON = MediaType.get("application/json; charset=utf-8");
    
    private final OkHttpClient client = new OkHttpClient();
    
    public String sendSMS(String recipient, String senderId, String message) throws Exception {
        JSONObject json = new JSONObject();
        json.put("recipient", recipient);
        json.put("sender_id", senderId);
        json.put("message", message);
        
        RequestBody body = RequestBody.create(json.toString(), JSON);
        
        Request request = new Request.Builder()
            .url(BASE_URL + "/sms/send")
            .addHeader("Authorization", "Bearer " + API_KEY)
            .post(body)
            .build();
        
        try (Response response = client.newCall(request).execute()) {
            return response.body().string();
        }
    }
}

import kotlinx.coroutines.*
import java.net.HttpURLConnection
import java.net.URL
import org.json.JSONObject

class SMSClient(private val apiKey: String) {
    private val baseUrl = "https://app.1smsafrica.com/api/v3"
    
    suspend fun sendSMS(recipient: String, senderId: String, message: String): String {
        return withContext(Dispatchers.IO) {
            val url = URL("$baseUrl/sms/send")
            val connection = url.openConnection() as HttpURLConnection
            
            connection.requestMethod = "POST"
            connection.setRequestProperty("Authorization", "Bearer $apiKey")
            connection.setRequestProperty("Content-Type", "application/json")
            connection.doOutput = true
            
            val json = JSONObject().apply {
                put("recipient", recipient)
                put("sender_id", senderId)
                put("message", message)
            }
            
            connection.outputStream.use { it.write(json.toString().toByteArray()) }
            connection.inputStream.bufferedReader().readText()
        }
    }
    
    suspend fun checkBalance(): String {
        return withContext(Dispatchers.IO) {
            val url = URL("$baseUrl/balance")
            val connection = url.openConnection() as HttpURLConnection
            connection.setRequestProperty("Authorization", "Bearer $apiKey")
            connection.inputStream.bufferedReader().readText()
        }
    }
}

// Utilisation
fun main() = runBlocking {
    val client = SMSClient("VOTRE_CLE_API")
    val result = client.sendSMS("2250700000000", "MonEntreprise", "Bonjour!")
    println(result)
}

import io.ktor.client.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*

val client = HttpClient()

suspend fun sendSMS(recipient: String, senderId: String, message: String): String {
    val response: HttpResponse = client.post("https://app.1smsafrica.com/api/v3/sms/send") {
        headers {
            append("Authorization", "Bearer VOTRE_CLE_API")
            append("Content-Type", "application/json")
        }
        setBody("""{"recipient":"$recipient","sender_id":"$senderId","message":"$message"}""")
    }
    return response.bodyAsText()
}

import Foundation

class SMSClient {
    private let apiKey: String
    private let baseURL = "https://app.1smsafrica.com/api/v3"
    
    init(apiKey: String) {
        self.apiKey = apiKey
    }
    
    func sendSMS(recipient: String, senderId: String, message: String, completion: @escaping (Result<[String: Any], Error>) -> Void) {
        guard let url = URL(string: "\(baseURL)/sms/send") else { return }
        
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        
        let body: [String: Any] = [
            "recipient": recipient,
            "sender_id": senderId,
            "message": message
        ]
        request.httpBody = try? JSONSerialization.data(withJSONObject: body)
        
        URLSession.shared.dataTask(with: request) { data, response, error in
            if let error = error {
                completion(.failure(error))
                return
            }
            guard let data = data,
                  let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
                return
            }
            completion(.success(json))
        }.resume()
    }
    
    func checkBalance(completion: @escaping (Result<[String: Any], Error>) -> Void) {
        guard let url = URL(string: "\(baseURL)/balance") else { return }
        
        var request = URLRequest(url: url)
        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
        
        URLSession.shared.dataTask(with: request) { data, _, error in
            if let error = error {
                completion(.failure(error))
                return
            }
            guard let data = data,
                  let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
                return
            }
            completion(.success(json))
        }.resume()
    }
}

// Utilisation
let client = SMSClient(apiKey: "VOTRE_CLE_API")
client.sendSMS(recipient: "2250700000000", senderId: "MonEntreprise", message: "Bonjour!") { result in
    switch result {
    case .success(let json): print("Succès: \(json)")
    case .failure(let error): print("Erreur: \(error)")
    }
}

import 'dart:convert';
import 'package:http/http.dart' as http;

class SMSClient {
  final String apiKey;
  final String baseUrl = 'https://app.1smsafrica.com/api/v3';
  
  SMSClient(this.apiKey);
  
  Future<Map<String, dynamic>> sendSMS({
    required String recipient,
    required String senderId,
    required String message,
  }) async {
    final response = await http.post(
      Uri.parse('$baseUrl/sms/send'),
      headers: {
        'Authorization': 'Bearer $apiKey',
        'Content-Type': 'application/json',
      },
      body: jsonEncode({
        'recipient': recipient,
        'sender_id': senderId,
        'message': message,
      }),
    );
    
    return jsonDecode(response.body);
  }
  
  Future<Map<String, dynamic>> checkBalance() async {
    final response = await http.get(
      Uri.parse('$baseUrl/balance'),
      headers: {'Authorization': 'Bearer $apiKey'},
    );
    
    return jsonDecode(response.body);
  }
}

// Utilisation dans Flutter
void main() async {
  final client = SMSClient('VOTRE_CLE_API');
  
  final result = await client.sendSMS(
    recipient: '2250700000000',
    senderId: 'MonEntreprise',
    message: 'Bonjour depuis Flutter!',
  );
  
  print('Résultat: $result');
}

package main

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

const (
    apiKey  = "VOTRE_CLE_API"
    baseURL = "https://app.1smsafrica.com/api/v3"
)

type SMSRequest struct {
    Recipient string `json:"recipient"`
    SenderID  string `json:"sender_id"`
    Message   string `json:"message"`
}

type SMSResponse struct {
    Status  string `json:"status"`
    Message string `json:"message"`
    Data    struct {
        UID string `json:"uid"`
    } `json:"data"`
}

func sendSMS(recipient, senderID, message string) (*SMSResponse, error) {
    payload := SMSRequest{
        Recipient: recipient,
        SenderID:  senderID,
        Message:   message,
    }
    
    jsonData, _ := json.Marshal(payload)
    
    req, _ := http.NewRequest("POST", baseURL+"/sms/send", bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    
    var result SMSResponse
    json.Unmarshal(body, &result)
    
    return &result, nil
}

func main() {
    result, err := sendSMS("2250700000000", "MonEntreprise", "Bonjour depuis Go!")
    if err != nil {
        fmt.Println("Erreur:", err)
        return
    }
    fmt.Printf("SMS envoyé! ID: %s\n", result.Data.UID)
}

require 'net/http'
require 'uri'
require 'json'

class SMSClient
  API_KEY = 'VOTRE_CLE_API'
  BASE_URL = 'https://app.1smsafrica.com/api/v3'
  
  def send_sms(recipient:, sender_id:, message:)
    uri = URI.parse("\#{BASE_URL}/sms/send")
    
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    
    request = Net::HTTP::Post.new(uri.path)
    request['Authorization'] = "Bearer \#{API_KEY}"
    request['Content-Type'] = 'application/json'
    request.body = {
      recipient: recipient,
      sender_id: sender_id,
      message: message
    }.to_json
    
    response = http.request(request)
    JSON.parse(response.body)
  end
  
  def check_balance
    uri = URI.parse("\#{BASE_URL}/balance")
    
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    
    request = Net::HTTP::Get.new(uri.path)
    request['Authorization'] = "Bearer \#{API_KEY}"
    
    response = http.request(request)
    JSON.parse(response.body)
  end
end

# Utilisation
client = SMSClient.new
result = client.send_sms(
  recipient: '2250700000000',
  sender_id: 'MonEntreprise',
  message: 'Bonjour depuis Ruby!'
)
puts "Résultat: \#{result}"

use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION, CONTENT_TYPE};
use serde::{Deserialize, Serialize};

const API_KEY: &str = "VOTRE_CLE_API";
const BASE_URL: &str = "https://app.1smsafrica.com/api/v3";

#[derive(Serialize)]
struct SMSRequest {
    recipient: String,
    sender_id: String,
    message: String,
}

#[derive(Deserialize, Debug)]
struct SMSResponse {
    status: String,
    message: Option<String>,
    data: Option<SMSData>,
}

#[derive(Deserialize, Debug)]
struct SMSData {
    uid: String,
}

async fn send_sms(recipient: &str, sender_id: &str, message: &str) -> Result<SMSResponse, reqwest::Error> {
    let client = reqwest::Client::new();
    
    let mut headers = HeaderMap::new();
    headers.insert(AUTHORIZATION, HeaderValue::from_str(&format!("Bearer {}", API_KEY)).unwrap());
    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
    
    let payload = SMSRequest {
        recipient: recipient.to_string(),
        sender_id: sender_id.to_string(),
        message: message.to_string(),
    };
    
    let response = client
        .post(&format!("{}/sms/send", BASE_URL))
        .headers(headers)
        .json(&payload)
        .send()
        .await?
        .json::<SMSResponse>()
        .await?;
    
    Ok(response)
}

#[tokio::main]
async fn main() {
    match send_sms("2250700000000", "MonEntreprise", "Bonjour depuis Rust!").await {
        Ok(response) => println!("Succès: {:?}", response),
        Err(e) => println!("Erreur: {}", e),
    }
}

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

public class SMSClient
{
    private readonly HttpClient _client;
    private const string API_KEY = "VOTRE_CLE_API";
    private const string BASE_URL = "https://app.1smsafrica.com/api/v3";
    
    public SMSClient()
    {
        _client = new HttpClient();
        _client.BaseAddress = new Uri(BASE_URL);
        _client.DefaultRequestHeaders.Authorization = 
            new AuthenticationHeaderValue("Bearer", API_KEY);
        _client.DefaultRequestHeaders.Accept.Add(
            new MediaTypeWithQualityHeaderValue("application/json"));
    }
    
    public async Task<string> SendSMSAsync(string recipient, string senderId, string message)
    {
        var data = new { recipient, sender_id = senderId, message };
        var json = JsonSerializer.Serialize(data);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var response = await _client.PostAsync("/sms/send", content);
        return await response.Content.ReadAsStringAsync();
    }
    
    public async Task<string> CheckBalanceAsync()
    {
        var response = await _client.GetAsync("/balance");
        return await response.Content.ReadAsStringAsync();
    }
}

// Utilisation
class Program
{
    static async Task Main(string[] args)
    {
        var smsClient = new SMSClient();
        var result = await smsClient.SendSMSAsync("2250700000000", "MonEntreprise", "Bonjour!");
        Console.WriteLine($"Résultat: {result}");
    }
}

// Constantes
CONSTANTE
    API_KEY = "VOTRE_CLE_API"
    BASE_URL = "https://app.1smsafrica.com/api/v3"
FIN

// Procédure pour envoyer un SMS
PROCEDURE EnvoyerSMS(sDestinataire est une chaîne, sSenderId est une chaîne, sMessage est une chaîne)

// Création du JSON
jsonDonnees est un JSON
jsonDonnees.recipient = sDestinataire
jsonDonnees.sender_id = sSenderId
jsonDonnees.message = sMessage

// Configuration de la requête HTTP
cMaRequête est un httpRequête
cMaRequête.URL = BASE_URL + "/sms/send"
cMaRequête.Méthode = httpPost
cMaRequête.ContentType = "application/json"
cMaRequête.Contenu = JSONVersChaine(jsonDonnees)

// Ajout des en-têtes
HTTPAjouteEntête(cMaRequête, "Authorization", "Bearer " + API_KEY)
HTTPAjouteEntête(cMaRequête, "Accept", "application/json")

// Envoi de la requête
cMaRéponse est un httpRéponse = HTTPEnvoie(cMaRequête)

SI cMaRéponse.CodeEtat = 200 ALORS
    jsonRéponse est un JSON = JSONVersVariant(cMaRéponse.Contenu)
    SI jsonRéponse.status = "success" ALORS
        Info("SMS envoyé avec succès! ID: " + jsonRéponse.data.uid)
        RENVOYER Vrai
    FIN
FIN
RENVOYER Faux

// Procédure pour vérifier le solde
PROCEDURE VérifierSolde()

cMaRequête est un httpRequête
cMaRequête.URL = BASE_URL + "/balance"
cMaRequête.Méthode = httpGet

HTTPAjouteEntête(cMaRequête, "Authorization", "Bearer " + API_KEY)
HTTPAjouteEntête(cMaRequête, "Accept", "application/json")

cMaRéponse est un httpRéponse = HTTPEnvoie(cMaRequête)

SI cMaRéponse.CodeEtat = 200 ALORS
    jsonRéponse est un JSON = JSONVersVariant(cMaRéponse.Contenu)
    SI jsonRéponse.status = "success" ALORS
        nSolde est un entier = jsonRéponse.data.balance
        Info("Solde: " + nSolde + " " + jsonRéponse.data.currency)
        RENVOYER nSolde
    FIN
FIN
RENVOYER -1

// Classe SMS1Africa
SMS1Africa est une Classe
    PRIVÉ
        m_sApiKey est une chaîne
        m_sBaseUrl est une chaîne
FIN

PROCÉDURE Constructeur(sApiKey est une chaîne)
    m_sApiKey = sApiKey
    m_sBaseUrl = "https://app.1smsafrica.com/api/v3"

PROCÉDURE EnvoyerSMS(sDestinataire, sSenderId, sMessage)
    json est un JSON
    json.recipient = sDestinataire
    json.sender_id = sSenderId
    json.message = sMessage
    
    cRequête est un httpRequête
    cRequête.URL = m_sBaseUrl + "/sms/send"
    cRequête.Méthode = httpPost
    cRequête.ContentType = "application/json"
    cRequête.Contenu = JSONVersChaine(json)
    
    HTTPAjouteEntête(cRequête, "Authorization", "Bearer " + m_sApiKey)
    cRéponse est un httpRéponse = HTTPEnvoie(cRequête)
    RENVOYER cRéponse.Contenu

// Utilisation:
// monClient est un SMS1Africa("VOTRE_CLE_API")
// monClient.EnvoyerSMS("2250700000000", "MonEntreprise", "Test")

# Envoyer un SMS
curl -X POST "https://app.1smsafrica.com/api/v3/sms/send" \
  -H "Authorization: Bearer VOTRE_CLE_API" \
  -H "Content-Type: application/json" \
  -d '{"recipient": "2250700000000", "sender_id": "MonEntreprise", "message": "Bonjour!"}'

# Vérifier le solde
curl -X GET "https://app.1smsafrica.com/api/v3/balance" \
  -H "Authorization: Bearer VOTRE_CLE_API" \
  -H "Accept: application/json"

# Envoyer des SMS en masse
curl -X POST "https://app.1smsafrica.com/api/v3/sms/send-bulk" \
  -H "Authorization: Bearer VOTRE_CLE_API" \
  -H "Content-Type: application/json" \
  -d '{"recipients": ["225070000001", "225070000002"], "sender_id": "MonEntreprise", "message": "Promo!"}'