NewHope SMS API

import requests

API_KEY    = "YOUR_API_KEY"    # dashboard → API Keys
SECRET_KEY = "YOUR_SECRET_KEY" # save once, never shown again
BASE       = "https://sms.newhope.co.tz/v1"

session = requests.Session()
session.headers.update({
    "Authorization": f"ApiKey {API_KEY}:{SECRET_KEY}",
    "Content-Type": "application/json",
})

r = session.get(f"{BASE}/sender-ids/")
print(r.json())

const axios = require('axios');

const API_KEY    = 'YOUR_API_KEY';    // dashboard → API Keys
const SECRET_KEY = 'YOUR_SECRET_KEY'; // save once, never shown again

const api = axios.create({
  baseURL: 'https://sms.newhope.co.tz/v1',
  headers: {
    'Authorization': `ApiKey ${API_KEY}:${SECRET_KEY}`,
    'Content-Type': 'application/json',
  },
});

const { data } = await api.get('/sender-ids/');
console.log(data);

const API_KEY    = 'YOUR_API_KEY';
const SECRET_KEY = 'YOUR_SECRET_KEY';

const headers = {
  'Authorization': `ApiKey ${API_KEY}:${SECRET_KEY}`,
  'Content-Type': 'application/json',
};

const res  = await fetch('https://sms.newhope.co.tz/v1/sender-ids/', { headers });
const data = await res.json();
console.log(data);

<?php
$apiKey    = 'YOUR_API_KEY';    // dashboard → API Keys
$secretKey = 'YOUR_SECRET_KEY'; // save once, never shown again

$ch = curl_init('https://sms.newhope.co.tz/v1/sender-ids/');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: ApiKey ' . $apiKey . ':' . $secretKey,
    ],
]);
$data = json_decode(curl_exec($ch), true);
curl_close($ch);
print_r($data);

<?php
use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://sms.newhope.co.tz/v1/',
    'headers'  => [
        'Authorization' => 'ApiKey ' . $apiKey . ':' . $secretKey,
        'Content-Type'  => 'application/json',
    ],
]);

$res  = $client->get('sender-ids/');
$data = json_decode($res->getBody(), true);

import okhttp3.*;

String apiKey    = "YOUR_API_KEY";
String secretKey = "YOUR_SECRET_KEY";

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
    .url("https://sms.newhope.co.tz/v1/sender-ids/")
    .addHeader("Authorization", "ApiKey " + apiKey + ":" + secretKey)
    .build();

try (Response response = client.newCall(request).execute()) {
    System.out.println(response.body().string());
}

import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://sms.newhope.co.tz/v1/sender-ids/"))
    .header("Authorization", "ApiKey " + apiKey + ":" + secretKey)
    .GET()
    .build();

HttpResponse<String> response = client.send(request,
    HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

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

var apiKey    = "YOUR_API_KEY";
var secretKey = "YOUR_SECRET_KEY";

var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", $"ApiKey {apiKey}:{secretKey}");

var senderIds = await client.GetFromJsonAsync<List<object>>(
    "https://sms.newhope.co.tz/v1/sender-ids/");
Console.WriteLine(senderIds);

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

// Add to pubspec.yaml: http: ^1.2.0

const apiKey    = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';

final headers = {
  'Authorization': 'ApiKey $apiKey:$secretKey',
  'Content-Type': 'application/json',
};

final res = await http.get(
  Uri.parse('https://sms.newhope.co.tz/v1/sender-ids/'),
  headers: headers,
);
final data = jsonDecode(res.body);
print(data);

package main

import (
    "fmt"; "io"; "net/http"
)

func main() {
    apiKey    := "YOUR_API_KEY"
    secretKey := "YOUR_SECRET_KEY"

    req, _ := http.NewRequest("GET",
        "https://sms.newhope.co.tz/v1/sender-ids/", nil)
    req.Header.Set("Authorization", "ApiKey "+apiKey+":"+secretKey)

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

require 'net/http'
require 'json'

api_key    = 'YOUR_API_KEY'
secret_key = 'YOUR_SECRET_KEY'

uri = URI('https://sms.newhope.co.tz/v1/sender-ids/')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = "ApiKey #{api_key}:#{secret_key}"

res  = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
data = JSON.parse(res.body)
puts data

r = session.post("/sms/send/", json={
    "recipient":   "+255712345678",
    "message":     "Hello from NewHope SMS!",
    "sender_id":   "NewHope",
    "webhook_url": "https://yourapp.com/dlr",
})
print(r.json())  # {'id': '...', 'status': 'sent', 'cost': '20.00'}

const { data } = await api.post('/sms/send/', {
  recipient:   '+255712345678',
  message:     'Hello from NewHope SMS!',
  sender_id:   'NewHope',
  webhook_url: 'https://yourapp.com/dlr',
});

$ch = curl_init('https://sms.newhope.co.tz/v1/sms/send/');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true,
    CURLOPT_HTTPHEADER     => ['Authorization: ApiKey '.$apiKey.':'.$secretKey, 'Content-Type: application/json'],
    CURLOPT_POSTFIELDS     => json_encode(['recipient'=>'+255712345678','message'=>'Hello!','sender_id'=>'NewHope']),
]);
print_r(json_decode(curl_exec($ch), true)); curl_close($ch);

String body = """{"recipient":"+255712345678","message":"Hello!","sender_id":"NewHope"}""";
RequestBody rb = RequestBody.create(body, MediaType.get("application/json"));
Request req = new Request.Builder()
    .url("https://sms.newhope.co.tz/v1/sms/send/")
    .addHeader("Authorization", "ApiKey " + apiKey + ":" + secretKey)
    .post(rb).build();
try (Response r = client.newCall(req).execute()) { System.out.println(r.body().string()); }

var payload = new { recipient = "+255712345678", message = "Hello!", sender_id = "NewHope" };
var res = await client.PostAsJsonAsync("https://sms.newhope.co.tz/v1/sms/send/", payload);
var data = await res.Content.ReadFromJsonAsync<JsonElement>();
Console.WriteLine(data);

final res = await http.post(
  Uri.parse('https://sms.newhope.co.tz/v1/sms/send/'),
  headers: headers,
  body: jsonEncode({'recipient': '+255712345678', 'message': 'Hello!', 'sender_id': 'NewHope'}),
);
print(jsonDecode(res.body));

with open("contacts.csv", "rb") as f:
    r = requests.post(
        f"{BASE}/contacts/LIST_UUID/import/",
        files={"file": ("contacts.csv", f, "text/csv")},
        headers={"Authorization": f"ApiKey {API_KEY}:{SECRET_KEY}"},
    )
print(r.json())  # {'imported': 1200, 'skipped': 15, ...}

const FormData = require('form-data');
const fs = require('fs');

const form = new FormData();
form.append('file', fs.createReadStream('contacts.csv'));

const { data } = await axios.post('/contacts/LIST_UUID/import/', form, {
  headers: { ...form.getHeaders() },
});
console.log(data);

var request = http.MultipartRequest(
  'POST',
  Uri.parse('https://sms.newhope.co.tz/v1/contacts/LIST_UUID/import/'),
);
request.headers['Authorization'] = 'ApiKey $apiKey:$secretKey';
request.files.add(await http.MultipartFile.fromPath('file', 'contacts.csv'));
var response = await request.send();
print(await response.stream.bytesToString());

# Step 1 — send OTP
send = session.post(f"{BASE}/otp/send/", json={"phone": "+255712345678"})
request_id = send.json()["request_id"]
print(f"OTP sent — expires in {send.json()['expires_in']}s")

# Step 2 — user reads code; then verify
verify = session.post(f"{BASE}/otp/verify/", json={"request_id": request_id, "otp": user_input})
print("Valid:", verify.json()["valid"])

// Step 1 — send OTP
final sendRes = await http.post(Uri.parse('$BASE/otp/send/'), headers: headers,
  body: jsonEncode({'phone': '+255712345678'}));
final requestId = jsonDecode(sendRes.body)['request_id'];

// Step 2 — verify OTP
final verifyRes = await http.post(Uri.parse('$BASE/otp/verify/'), headers: headers,
  body: jsonEncode({'request_id': requestId, 'otp': userInput}));
final valid = jsonDecode(verifyRes.body)['valid'];
print('OTP valid: $valid');

from flask import Flask, request
app = Flask(__name__)

@app.route('/dlr', methods=['POST'])
def dlr():
    d = request.json
    print(f"[{d['status'].upper()}] {d['recipient']} — {d['message_id']}")
    if d['status'] == 'delivered':
        pass  # update DB, send follow-up, etc.
    return 'OK', 200  # MUST return 200

app.post('/dlr', (req, res) => {
  const { message_id, recipient, status } = req.body;
  console.log(`[${status.toUpperCase()}] ${recipient} — ${message_id}`);
  if (status === 'delivered') { /* update DB */ }
  res.sendStatus(200);  // MUST return 200
});

$d = json_decode(file_get_contents('php://input'), true);
error_log("DLR [{$d['status']}] {$d['recipient']} — {$d['message_id']}");
if ($d['status'] === 'delivered') { /* update DB */ }
http_response_code(200); echo 'OK';

@PostMapping("/dlr")
public ResponseEntity<String> dlr(@RequestBody Map<String, Object> payload) {
    String status = (String) payload.get("status");
    log.info("DLR [{}] {} — {}", status, payload.get("recipient"), payload.get("message_id"));
    if ("delivered".equals(status)) { /* update DB */ }
    return ResponseEntity.ok("OK");  // MUST return 200
}

[HttpPost("/dlr")]
public IActionResult Dlr([FromBody] JsonElement payload) {
    var status = payload.GetProperty("status").GetString();
    var recipient = payload.GetProperty("recipient").GetString();
    _logger.LogInformation("DLR [{status}] {recipient}", status, recipient);
    if (status == "delivered") { /* update DB */ }
    return Ok("OK");  // MUST return 200
}

import time, requests

def send_sms_with_retry(session, payload, max_retries=3):
    for attempt in range(max_retries):
        r = session.post(f"{BASE}/sms/send/", json=payload)
        if r.status_code == 201:
            return r.json()
        if r.status_code == 429 or r.status_code >= 500:
            wait = 2 ** attempt  # 1s, 2s, 4s
            time.sleep(wait)
            continue
        r.raise_for_status()  # 4xx errors — don't retry
    raise Exception("Max retries exceeded")

async function sendWithRetry(payload, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const { data } = await api.post('/sms/send/', payload);
      return data;
    } catch (err) {
      const status = err.response?.status;
      if (status === 429 || status >= 500) {
        await new Promise(r => setTimeout(r, 1000 * 2 ** i));
        continue;
      }
      throw err;  // 4xx — don't retry
    }
  }
  throw new Error('Max retries exceeded');
}