DevSMS API

<?php
// DevSMS API - PHP Example

$token = "your_api_token_here";
$baseUrl = "https://devsms.uz/api";

// SMS Yuborish
function sendSMS($token, $baseUrl, $phone, $message) {
    $ch = curl_init("$baseUrl/send_sms.php");
    
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST => true,
        CURLOPT_HTTPHEADER => [
            "Authorization: Bearer $token",
            "Content-Type: application/json"
        ],
        CURLOPT_POSTFIELDS => json_encode([
            "phone" => $phone,
            "message" => $message
        ])
    ]);
    
    $response = curl_exec($ch);
    curl_close($ch);
    
    return json_decode($response, true);
}

// Balansni olish
function getBalance($token, $baseUrl) {
    $ch = curl_init("$baseUrl/get_balance.php");
    
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => [
            "Authorization: Bearer $token"
        ]
    ]);
    
    $response = curl_exec($ch);
    curl_close($ch);
    
    return json_decode($response, true);
}

// Ishlatish
$result = sendSMS($token, $baseUrl, "998901234567", "Salom!");
print_r($result);

$balance = getBalance($token, $baseUrl);
print_r($balance);
?>

# DevSMS API - Python Example
import requests

TOKEN = "your_api_token_here"
BASE_URL = "https://devsms.uz/api"

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

# SMS Yuborish
def send_sms(phone: str, message: str) -> dict:
    response = requests.post(
        f"{BASE_URL}/send_sms.php",
        headers=headers,
        json={
            "phone": phone,
            "message": message
        }
    )
    return response.json()

# Balansni olish
def get_balance() -> dict:
    response = requests.get(
        f"{BASE_URL}/get_balance.php",
        headers=headers
    )
    return response.json()

# SMS tarixini olish
def get_history(limit: int = 50, offset: int = 0) -> dict:
    response = requests.get(
        f"{BASE_URL}/get_history.php",
        headers=headers,
        params={"limit": limit, "offset": offset}
    )
    return response.json()

# Ishlatish
if __name__ == "__main__":
    # SMS yuborish
    result = send_sms("998901234567", "Salom!")
    print(result)
    
    # Balansni tekshirish
    balance = get_balance()
    print(f"Balans: {balance['data']['balance']} $")

// DevSMS API - JavaScript (Browser) Example

const TOKEN = "your_api_token_here";
const BASE_URL = "https://devsms.uz/api";

// SMS Yuborish
async function sendSMS(phone, message) {
    const response = await fetch(`${BASE_URL}/send_sms.php`, {
        method: "POST",
        headers: {
            "Authorization": `Bearer ${TOKEN}`,
            "Content-Type": "application/json"
        },
        body: JSON.stringify({ phone, message })
    });
    return response.json();
}

// Balansni olish
async function getBalance() {
    const response = await fetch(`${BASE_URL}/get_balance.php`, {
        headers: {
            "Authorization": `Bearer ${TOKEN}`
        }
    });
    return response.json();
}

// SMS tarixini olish
async function getHistory(limit = 50, offset = 0) {
    const response = await fetch(
        `${BASE_URL}/get_history.php?limit=${limit}&offset=${offset}`,
        {
            headers: {
                "Authorization": `Bearer ${TOKEN}`
            }
        }
    );
    return response.json();
}

// Ishlatish
(async () => {
    // SMS yuborish
    const result = await sendSMS("998901234567", "Salom!");
    console.log(result);
    
    // Balansni tekshirish
    const balance = await getBalance();
    console.log(`Balans: ${balance.data.balance} $`);
})();

// DevSMS API - Node.js Example
// npm install axios

const axios = require('axios');

const TOKEN = "your_api_token_here";
const BASE_URL = "https://devsms.uz/api";

const api = axios.create({
    baseURL: BASE_URL,
    headers: {
        "Authorization": `Bearer ${TOKEN}`,
        "Content-Type": "application/json"
    }
});

// SMS Yuborish
async function sendSMS(phone, message) {
    const { data } = await api.post('/send_sms.php', { phone, message });
    return data;
}

// Balansni olish
async function getBalance() {
    const { data } = await api.get('/get_balance.php');
    return data;
}

// SMS statusini olish
async function getSMSStatus(smsId) {
    const { data } = await api.get(`/get_status.php?sms_id=${smsId}`);
    return data;
}

// SMS tarixini olish
async function getHistory(limit = 50, offset = 0) {
    const { data } = await api.get('/get_history.php', {
        params: { limit, offset }
    });
    return data;
}

// Ishlatish
(async () => {
    try {
        // SMS yuborish
        const result = await sendSMS("998901234567", "Salom!");
        console.log("SMS yuborildi:", result);
        
        // Balansni tekshirish
        const balance = await getBalance();
        console.log(`Balans: ${balance.data.balance} $`);
    } catch (error) {
        console.error("Xatolik:", error.response?.data || error.message);
    }
})();

// DevSMS API - Java Example
import java.net.http.*;
import java.net.URI;

public class DevSMSClient {
    private static final String TOKEN = "your_api_token_here";
    private static final String BASE_URL = "https://devsms.uz/api";
    private final HttpClient client = HttpClient.newHttpClient();

    // SMS Yuborish
    public String sendSMS(String phone, String message) throws Exception {
        String json = String.format(
            "{\"phone\":\"%s\",\"message\":\"%s\"}", 
            phone, message
        );
        
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/send_sms.php"))
            .header("Authorization", "Bearer " + TOKEN)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(json))
            .build();
        
        HttpResponse<String> response = client.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        return response.body();
    }

    // Balansni olish
    public String getBalance() throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/get_balance.php"))
            .header("Authorization", "Bearer " + TOKEN)
            .GET()
            .build();
        
        HttpResponse<String> response = client.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        return response.body();
    }

    public static void main(String[] args) throws Exception {
        DevSMSClient client = new DevSMSClient();
        
        // SMS yuborish
        String result = client.sendSMS("998901234567", "Salom!");
        System.out.println(result);
        
        // Balansni tekshirish
        String balance = client.getBalance();
        System.out.println(balance);
    }
}

// DevSMS API - C# Example
using System.Net.Http;
using System.Text;
using System.Text.Json;

public class DevSMSClient
{
    private const string TOKEN = "your_api_token_here";
    private const string BASE_URL = "https://devsms.uz/api";
    private readonly HttpClient _client;

    public DevSMSClient()
    {
        _client = new HttpClient();
        _client.DefaultRequestHeaders.Add(
            "Authorization", $"Bearer {TOKEN}"
        );
    }

    // SMS Yuborish
    public async Task<string> SendSMSAsync(string phone, string message)
    {
        var data = new { phone, message };
        var json = JsonSerializer.Serialize(data);
        var content = new StringContent(
            json, 
            Encoding.UTF8, 
            "application/json"
        );

        var response = await _client.PostAsync(
            $"{BASE_URL}/send_sms.php", 
            content
        );
        
        return await response.Content.ReadAsStringAsync();
    }

    // Balansni olish
    public async Task<string> GetBalanceAsync()
    {
        var response = await _client.GetAsync(
            $"{BASE_URL}/get_balance.php"
        );
        
        return await response.Content.ReadAsStringAsync();
    }

    // SMS statusini olish
    public async Task<string> GetStatusAsync(int smsId)
    {
        var response = await _client.GetAsync(
            $"{BASE_URL}/get_status.php?sms_id={smsId}"
        );
        
        return await response.Content.ReadAsStringAsync();
    }
}

// Ishlatish
class Program
{
    static async Task Main(string[] args)
    {
        var client = new DevSMSClient();
        
        // SMS yuborish
        var result = await client.SendSMSAsync("998901234567", "Salom!");
        Console.WriteLine(result);
        
        // Balansni tekshirish
        var balance = await client.GetBalanceAsync();
        Console.WriteLine(balance);
    }
}

// DevSMS API - Go Example
package main

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

const (
    TOKEN    = "your_api_token_here"
    BASE_URL = "https://devsms.uz/api"
)

type SMSRequest struct {
    Phone   string `json:"phone"`
    Message string `json:"message"`
}

// SMS Yuborish
func sendSMS(phone, message string) (map[string]interface{}, error) {
    data := SMSRequest{Phone: phone, Message: message}
    jsonData, _ := json.Marshal(data)

    req, _ := http.NewRequest(
        "POST", 
        BASE_URL+"/send_sms.php", 
        bytes.NewBuffer(jsonData),
    )
    req.Header.Set("Authorization", "Bearer "+TOKEN)
    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 map[string]interface{}
    json.Unmarshal(body, &result)
    
    return result, nil
}

// Balansni olish
func getBalance() (map[string]interface{}, error) {
    req, _ := http.NewRequest("GET", BASE_URL+"/get_balance.php", nil)
    req.Header.Set("Authorization", "Bearer "+TOKEN)

    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 map[string]interface{}
    json.Unmarshal(body, &result)
    
    return result, nil
}

func main() {
    // SMS yuborish
    result, _ := sendSMS("998901234567", "Salom!")
    fmt.Printf("SMS: %v\n", result)

    // Balansni tekshirish
    balance, _ := getBalance()
    fmt.Printf("Balans: %v\n", balance)
}