Documentation de l'API SMS

# Envoi d'un SMS avec cURL via le terminal
curl -X POST 'https://sms.bammite.com/api.php' \
  -H 'Content-Type: application/json' \
  -H 'X-API-KEY: votre_cle_api' \
  -H 'X-PRIVATE-KEY: votre_private_key' \
  -d '{ "telephone": "+221771234567", "message": "Bonjour depuis l API !", "name": "Bammite" }'

<?php
// Configuration de l'API et des données
$url = "https://sms.bammite.com/api.php";
$data = [
    "telephone" => "+221771234567",
    "message"   => "Bonjour depuis l'API !",
    "name"      => "Bammite" // Optionnel
];

// Initialisation de cURL
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Content-Type: application/json",
    "X-API-KEY: votre_cle_api",
    "X-PRIVATE-KEY: votre_private_key"
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

// Exécution de la requête
$response = curl_exec($ch);

if (curl_errno($ch)) {
    echo 'Erreur cURL : ' . curl_error($ch);
} else {
    $result = json_decode($response, true);
    print_r($result);
}

curl_close($ch);
?>

// Envoi d'un SMS avec l'API Fetch (Node.js 18+ ou navigateur)
const url = 'https://sms.bammite.com/api.php';
const apiKey     = 'votre_cle_api';
const privateKey = 'votre_private_key';

const payload = {
  telephone: '+221771234567',
  message:   "Bonjour depuis l'API !",
  name:      'Bammite' // Optionnel
};

fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type':  'application/json',
    'X-API-KEY':    apiKey,
    'X-PRIVATE-KEY': privateKey
  },
  body: JSON.stringify(payload)
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Erreur :', error));

import requests

url = "https://sms.bammite.com/api.php"
headers = {
    "Content-Type":  "application/json",
    "X-API-KEY":    "votre_cle_api",
    "X-PRIVATE-KEY": "votre_private_key"
}
payload = {
    "telephone": "+221771234567",
    "message":   "Bonjour depuis l'API !",
    "name":      "Bammite"  # Optionnel
}

try:
    response = requests.post(url, headers=headers, json=payload)
    response.raise_for_status()
    print(response.json())
except requests.exceptions.RequestException as e:
    print(f"Erreur: {e}")

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

public class BammiteSms {
    public static void main(String[] args) {
        String url        = "https://sms.bammite.com/api.php";
        String apiKey     = "votre_cle_api";
        String privateKey = "votre_private_key";
        String jsonPayload = "{"
                + "\"telephone\":\"+221771234567\","
                + "\"message\":\"Bonjour depuis l'API !\","
                + "\"name\":\"Bammite\""
                + "}";

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Content-Type",  "application/json")
                .header("X-API-KEY",    apiKey)
                .header("X-PRIVATE-KEY", privateKey)
                .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
                .build();

        client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body)
                .thenAccept(System.out::println)
                .join();
    }
}

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

uri = URI.parse("https://sms.bammite.com/api.php")
header = {
  'Content-Type'  => 'application/json',
  'X-API-KEY'     => 'votre_cle_api',
  'X-PRIVATE-KEY' => 'votre_private_key'
}
payload = {
  telephone: '+221771234567',
  message:   "Bonjour depuis l'API !",
  name:      'Bammite' # Optionnel
}

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri.request_uri, header)
request.body = payload.to_json

response = http.request(request)
puts JSON.parse(response.body)

package main

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

func main() {
	url := "https://sms.bammite.com/api.php"
	payload := map[string]string{
		"telephone": "+221771234567",
		"message":   "Bonjour depuis l'API !",
		"name":      "Bammite", // Optionnel
	}
	jsonValue, _ := json.Marshal(payload)

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonValue))
	if err != nil {
		fmt.Printf("Erreur request: %s\n", err)
		return
	}

	req.Header.Set("Content-Type",  "application/json")
	req.Header.Set("X-API-KEY",    "votre_cle_api")
	req.Header.Set("X-PRIVATE-KEY", "votre_private_key")

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

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url = "https://sms.bammite.com/api.php";
    let client = reqwest::Client::new();
    
    let mut headers = HeaderMap::new();
    headers.insert(CONTENT_TYPE,    HeaderValue::from_static("application/json"));
    headers.insert("X-API-KEY",    HeaderValue::from_static("votre_cle_api"));
    headers.insert("X-PRIVATE-KEY", HeaderValue::from_static("votre_private_key"));

    let payload = json!({
        "telephone": "+221771234567",
        "message":   "Bonjour depuis l'API !",
        "name":      "Bammite"  // Optionnel
    });

    let res = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await?
        .text()
        .await?;

    println!("{}", res);
    Ok(())
}

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

void main() async {
  var url = Uri.parse('https://sms.bammite.com/api.php');
  var headers = {
    'Content-Type':  'application/json',
    'X-API-KEY':    'votre_cle_api',
    'X-PRIVATE-KEY': 'votre_private_key',
  };
  var body = jsonEncode({
    'telephone': '+221771234567',
    'message':   "Bonjour depuis l'API !",
    'name':      'Bammite', // Optionnel
  });

  try {
    var response = await http.post(url, headers: headers, body: body);
    if (response.statusCode == 200) {
      print(jsonDecode(response.body));
    } else {
      print('Erreur: ${response.statusCode}');
    }
  } catch (e) {
    print('Erreur: $e');
  }
}

<!DOCTYPE html>
<html lang="fr">
<head>
  <meta charset="UTF-8" />
  <title>Envoi SMS Bammite</title>
</head>
<body>
  <form id="smsForm">
    <label for="phone">Numéro :</label>
    <input id="phone" type="text" value="+221781941351" />
    
    <label for="message">Message :</label>
    <textarea id="message">Bonjour depuis ma page web.</textarea>
    
    <button type="submit">Envoyer</button>
  </form>

<div id="smsResult" style="display:none; margin-top:20px; padding:16px; border-radius:8px; max-width:600px; white-space:pre-wrap; font-family: monospace;"></div>

<script>
const smsResult = document.querySelector('#smsResult');

function renderResult(message, isSuccess = true) {
  smsResult.style.display = 'block';
  smsResult.style.backgroundColor = isSuccess ? '#e6f4ea' : '#fce8e6';
  smsResult.style.color = isSuccess ? '#137333' : '#c5221f';
  smsResult.style.border = isSuccess ? '1px solid #ceead6' : '1px solid #fad2cf';
  smsResult.innerText = message;
}

document.querySelector('#smsForm').addEventListener('submit', async function(event) {
  event.preventDefault();
  renderResult('Envoi en cours…', true);

  try {
    const response = await fetch('https://sms.bammite.com/api.php', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-KEY': 'Votre_cle_api',
        'X-PRIVATE-KEY': 'Votre_private_key'
      },
      body: JSON.stringify({
        telephone: document.querySelector('#phone').value,
        message: document.querySelector('#message').value,
        name: 'attic' // Nom de l'expéditeur (optionnel)
      })
    });

    if (!response.ok) {
      const errorBody = await response.text();
      renderResult(`Erreur HTTP [${response.status} ${response.statusText}]\n${errorBody}`, false);
      return;
    }

    const result = await response.json();
    renderResult(result.message || JSON.stringify(result, null, 2), result.success === true);
  } catch (error) {
    renderResult(`Erreur d'envoi : ${error.message}\n(Vérifiez votre connexion ou les règles CORS si l'appel est fait depuis un navigateur)`, false);
  }
});
</script>
</body>
</html>