Python 3.10 o posterior. Instala requests con pip install requests, define ENVIATUSMS_API_KEY en el entorno y utiliza esta función con los ejemplos siguientes. No registres las URLs que contienen la clave.

import os
import requests


def request_api(path: str, data: dict | None = None) -> dict:
    key = os.environ["ENVIATUSMS_API_KEY"]
    method = "GET"
    if data is not None:
        method = "POST"

    response = requests.request(
        method,
        f"https://www.enviatusms.com/api/v1/{path}",
        params={"api_key": key},
        json=data,
        timeout=30,
    )
    if response.status_code >= 400:
        raise RuntimeError(f"HTTP {response.status_code}")

    result = response.json()
    if not isinstance(result, dict):
        raise RuntimeError("Respuesta inesperada")
    if ("status" in result and result["status"] != "ok") or (
        "success" in result and result["success"] is not True
    ):
        raise RuntimeError(result.get("msg") or result.get("error") or "Error de API")
    if "status" not in result and "success" not in result:
        raise RuntimeError("Respuesta inesperada")

    return result

result = request_api("balance")
print(result["balance"])
print(result["sms"])
                                    

result = request_api("sms-multi", {
    "numeros": ["04241234567", "04261234567"],
    "texto": "Hola desde Python",
})
print(result["campaign_id"])
                                    

result = request_api("sms-multi", {
    "numeros": ["04241234567", "04261234567"],
    "texto": ["Hola 0424", "Hola 0426"],
})
print(result["campaign_id"])
                                    

result = request_api("sms-costo", {
    "numeros": ["04241234567", "04261234567"],
    "texto": "Hola desde Python",
})
print(result["precio_usd"])
                                    

result = request_api("sms-costo", {
    "numeros": ["04241234567", "04261234567"],
    "texto": ["Hola 0424", "Hola 0426"],
})
print(result["precio_usd"])
                                    

campaign_id = 1
result = request_api(f"campaign/{campaign_id}")
print(result["message_text"])
                                    

result = request_api("acortar-url", {
    "link": "https://example.com",
})
print(result["link"])
                                    

Go (biblioteca estándar). Define ENVIATUSMS_API_KEY como variable de entorno; no guardes la clave en el código ni registres la URL.

package main

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

func main() {
    key := os.Getenv("ENVIATUSMS_API_KEY")
    if key == "" {
        panic("Falta ENVIATUSMS_API_KEY")
    }

    endpoint, err := url.Parse("https://www.enviatusms.com/api/v1/sms-multi")
    if err != nil {
        panic(err)
    }
    params := endpoint.Query()
    params.Set("api_key", key)
    endpoint.RawQuery = params.Encode()

    data, err := json.Marshal(map[string]interface{}{
        "numeros": []string{"04241234567"},
        "texto":   "Hola desde Go",
    })
    if err != nil {
        panic(err)
    }

    req, err := http.NewRequest("POST", endpoint.String(), bytes.NewReader(data))
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }
    if resp.StatusCode >= 400 {
        panic(fmt.Sprintf("HTTP %d", resp.StatusCode))
    }

    var result struct {
        Status string `json:"status"`
        Msg    string `json:"msg"`
    }
    if err := json.Unmarshal(body, &result); err != nil {
        panic(err)
    }
    if result.Status != "ok" {
        panic(result.Msg)
    }

    fmt.Println(string(body))
}

Rust: requiere reqwest con blocking y json, y serde_json. No registres URLs que contengan la clave.

use std::{env, error::Error, time::Duration};

fn main() -> Result<(), Box<dyn Error>> {
    let key = env::var("ENVIATUSMS_API_KEY")?;
    let mut url = reqwest::Url::parse("https://www.enviatusms.com/api/v1/sms-multi")?;
    url.query_pairs_mut().append_pair("api_key", &key);

    let client = reqwest::blocking::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;
    let response = client
        .post(url)
        .json(&serde_json::json!({
            "numeros": ["04241234567"],
            "texto": "Hola desde Rust"
        }))
        .send()?
        .error_for_status()?;

    let result: serde_json::Value = response.json()?;
    if result["status"] != "ok" {
        return Err(format!("API: {}", result["msg"]).into());
    }

    println!("{result}");
    Ok(())
}

Java 11 o posterior; requiere Jackson Databind. Lee la clave del entorno y evita registrar la URL.

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import java.time.Duration;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

class Example {
    public static void main(String[] args) throws Exception {
        String key = System.getenv("ENVIATUSMS_API_KEY");
        if (key == null || key.isEmpty()) {
            throw new IllegalStateException("Falta ENVIATUSMS_API_KEY");
        }

        String url = "https://www.enviatusms.com/api/v1/sms-multi?api_key="
            + URLEncoder.encode(key, StandardCharsets.UTF_8);
        String payload = "{\"numeros\":[\"04241234567\"],\"texto\":\"Hola desde Java\"}";

        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();
        HttpRequest request = HttpRequest.newBuilder(URI.create(url))
            .timeout(Duration.ofSeconds(30))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
            throw new IllegalStateException("HTTP " + response.statusCode());
        }

        JsonNode result = new ObjectMapper().readTree(response.body());
        if (!"ok".equals(result.path("status").asText())) {
            throw new IllegalStateException(result.path("msg").asText());
        }

        System.out.println(response.body());
    }
}

C# (.NET 6 o posterior). La API Key se obtiene del entorno; no registres las URLs completas.

using System.Net.Http.Json;
using System.Text.Json;

var key = Environment.GetEnvironmentVariable("ENVIATUSMS_API_KEY");
if (string.IsNullOrEmpty(key)) {
    throw new InvalidOperationException("Falta ENVIATUSMS_API_KEY");
}

var url = "https://www.enviatusms.com/api/v1/sms-multi?api_key=" + Uri.EscapeDataString(key);

using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
using var response = await client.PostAsJsonAsync(
    url,
    new { numeros = new[] { "04241234567" }, texto = "Hola desde C#" }
);
response.EnsureSuccessStatusCode();

using var result = await response.Content.ReadFromJsonAsync<JsonDocument>();
if (result is null) {
    throw new InvalidOperationException("Respuesta vacía");
}

if (result.RootElement.GetProperty("status").GetString() != "ok") {
    throw new InvalidOperationException(result.RootElement.GetProperty("msg").GetString());
}

Console.WriteLine(result.RootElement);