Pāriet uz saturu

Pārbaudiet ziņojuma statusu

Izsekojiet savu ziņojumu piegādes statusu, izmantojot statusa pārbaudes galapunktu.

Galapunkts

GET /bat/message/{messageId}

Pieprasījums

URL parametri

Parametrs Tips Nepieciešams Apraksts
messageId stīga Jā Unikāls ziņojuma identifikators no sūtīšanas atbildes

Autentifikācija

Izmantojiet kādu no trim autentifikācijas metodēm:

curl -X GET https://restapi.smsbat.com/bat/message/abc123def456 \
  -H "X-Authorization-Key: your-api-key"

curl -X GET https://restapi.smsbat.com/bat/message/abc123def456 \
  -u "username:password"

curl -X GET https://restapi.smsbat.com/bat/message/abc123def456 \
  -u "@:your-api-key"

Atbilde

Pamata atbilde

{
  "messagelistId": 123456,
  "messageId": "abc123def456",
  "deliverystatus": "delivered",
  "partscount": 1,
  "cost": 0.05
}

Atbildes lauki

Lauks Tips Apraksts
messagelistId vesels skaitlis Partijas identifikators
messageId stīga Unikāls ziņojuma identifikators
piegādes statuss stīga Pašreizējais piegādes statuss
detaļu skaits vesels skaitlis Ziņojuma daļu skaits
izmaksas numurs Ziņojuma izmaksas valūtas vienībās

Paplašināta atbilde (ar atkāpšanos)

Kad atkāpšanās ir konfigurēta, atbilde ietver papildu laukus:

{
  "messagelistId": 123456,
  "messageId": "abc123def456",
  "deliverystatus": "delivered",
  "partscount": 1,
  "cost": 0.05,
  "fallbacks": [
    {
      "type": "sms",
      "status": "not_used"
    }
  ],
  "extendedStatuses": {
    "viber": "delivered",
    "sms": "not_used"
  },
  "rate": 0.05,
  "rateAmount": 0.05,
  "rateCurrency": "USD",
  "billAmount": 0.05,
  "billCurrency": "USD"
}

Piegādes statusa vērtības

Statuss Apraksts
plānots Nosūtīšanas rindā
"apstrāde" Pašlaik tiek sūtīts
piegādāts Veiksmīgi piegādāts
"nepiegādājams" Piegāde neizdevās, ziņojums noraidīts
"pastāvīga kļūda" Noņemts no rindas pastāvīgas kļūdas dēļ

Statusa dzīves cikls

graph LR
    A[scheduled] --> B[processing]
    B --> C[delivered]
    B --> D[undeliverable]
    B --> E[permanenterror]

Ieplānots

Ziņojums tiek pieņemts un ievietots piegādes rindā:

{
  "deliverystatus": "scheduled",
  "partscount": 1
}

Apstrāde

Ziņa pašlaik tiek nosūtīta adresātam:

{
  "deliverystatus": "processing",
  "partscount": 1
}

Piegādāts

Ziņojums veiksmīgi piegādāts adresātam:

{
  "deliverystatus": "delivered",
  "partscount": 1,
  "cost": 0.05
}

Nepiegādājams

Ziņojumu nevarēja piegādāt (nederīgs numurs, tīkla kļūda):

{
  "deliverystatus": "undeliverable",
  "partscount": 1,
  "cost": 0.00
}

Pastāvīga kļūda

Ziņojums noņemts no rindas pastāvīgu piegādes problēmu dēļ:

{
  "deliverystatus": "permanenterror",
  "partscount": 1,
  "cost": 0.00
}

Pārbaudiet vairākus ziņojumus

Pārbaudiet vairāku ziņojumu statusu savā lietojumprogrammā:

// JavaScript example
async function checkMessageStatuses(messageIds) {
  const statuses = await Promise.all(
    messageIds.map(async (messageId) => {
      const response = await fetch(
        `https://restapi.smsbat.com/bat/message/${messageId}`,
        {
          headers: {
            'X-Authorization-Key': 'your-api-key'
          }
        }
      );
      return response.json();
    })
  );

  return statuses;
}

// Usage
const messageIds = ['abc123', 'def456', 'ghi789'];
const statuses = await checkMessageStatuses(messageIds);

statuses.forEach(status => {
  console.log(`Message ${status.messageId}: ${status.deliverystatus}`);
});

Statusa atjauninājumu aptauja

Aptaujāt statusa galapunktu, lai izsekotu piegādi:

// Poll every 5 seconds until delivered
async function waitForDelivery(messageId, maxAttempts = 12) {
  for (let i = 0; i < maxAttempts; i++) {
    const response = await fetch(
      `https://restapi.smsbat.com/bat/message/${messageId}`,
      {
        headers: { 'X-Authorization-Key': 'your-api-key' }
      }
    );

    const status = await response.json();

    if (status.deliverystatus === 'delivered') {
      return { success: true, status };
    }

    if (status.deliverystatus === 'undeliverable' ||
        status.deliverystatus === 'permanenterror') {
      return { success: false, status };
    }

    // Wait 5 seconds before next check
    await new Promise(resolve => setTimeout(resolve, 5000));
  }

  // Timeout after 60 seconds
  return { success: false, timeout: true };
}

Tīmekļa aizķeres alternatīva

Aptauju vietā izmantojiet tīmekļa aizķeres reāllaika statusa atjauninājumiem.

POST https://your-server.com/webhook
{
  "messageId": "abc123def456",
  "deliverystatus": "delivered",
  "timestamp": "2025-01-23T10:30:00Z",
  "cost": 0.05
}

Sazinieties ar sava konta pārzini, lai konfigurētu tīmekļa aizķeres URL.

Īstenošanas piemēri

Python

import requests
import time

def check_status(message_id, api_key):
    url = f"https://restapi.smsbat.com/bat/message/{message_id}"
    headers = {"X-Authorization-Key": api_key}

    response = requests.get(url, headers=headers)
    return response.json()

def wait_for_delivery(message_id, api_key, timeout=60):
    """Poll until delivered or timeout"""
    start_time = time.time()

    while time.time() - start_time < timeout:
        status = check_status(message_id, api_key)

        if status['deliverystatus'] == 'delivered':
            return {'success': True, 'status': status}

        if status['deliverystatus'] in ['undeliverable', 'permanenterror']:
            return {'success': False, 'status': status}

        time.sleep(5)

    return {'success': False, 'timeout': True}

# Usage
message_id = "abc123def456"
result = wait_for_delivery(message_id, "your-api-key")

if result['success']:
    print(f"Message delivered! Cost: {result['status']['cost']}")
else:
    print("Message delivery failed or timeout")

PHP

<?php

function checkStatus($messageId, $apiKey) {
    $url = "https://restapi.smsbat.com/bat/message/" . $messageId;

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        "X-Authorization-Key: " . $apiKey
    ]);

    $response = curl_exec($ch);
    curl_close($ch);

    return json_decode($response, true);
}

function waitForDelivery($messageId, $apiKey, $timeout = 60) {
    $startTime = time();

    while (time() - $startTime < $timeout) {
        $status = checkStatus($messageId, $apiKey);

        if ($status['deliverystatus'] === 'delivered') {
            return ['success' => true, 'status' => $status];
        }

        if (in_array($status['deliverystatus'],
                    ['undeliverable', 'permanenterror'])) {
            return ['success' => false, 'status' => $status];
        }

        sleep(5);
    }

    return ['success' => false, 'timeout' => true];
}

// Usage
$messageId = "abc123def456";
$result = waitForDelivery($messageId, "your-api-key");

if ($result['success']) {
    echo "Message delivered! Cost: " . $result['status']['cost'];
} else {
    echo "Message delivery failed or timeout";
}

Node.js

const axios = require('axios');

async function checkStatus(messageId, apiKey) {
  const response = await axios.get(
    `https://restapi.smsbat.com/bat/message/${messageId}`,
    {
      headers: { 'X-Authorization-Key': apiKey }
    }
  );

  return response.data;
}

async function waitForDelivery(messageId, apiKey, timeout = 60000) {
  const startTime = Date.now();

  while (Date.now() - startTime < timeout) {
    const status = await checkStatus(messageId, apiKey);

    if (status.deliverystatus === 'delivered') {
      return { success: true, status };
    }

    if (['undeliverable', 'permanenterror'].includes(
      status.deliverystatus
    )) {
      return { success: false, status };
    }

    // Wait 5 seconds
    await new Promise(resolve => setTimeout(resolve, 5000));
  }

  return { success: false, timeout: true };
}

// Usage
const messageId = 'abc123def456';
const result = await waitForDelivery(messageId, 'your-api-key');

if (result.success) {
  console.log(`Message delivered! Cost: ${result.status.cost}`);
} else {
  console.log('Message delivery failed or timeout');
}

Labākā prakse

Aptauju biežums

  • ✅ Aptauja ik pēc 5-10 sekundēm
  • ✅ Ieviesiet eksponenciālu atkāpšanos
  • ✅ Iestatiet saprātīgu taimautu (60-120 sekundes)
  • ❌ Neaptauj biežāk kā reizi sekundē
  • ❌ Neaptauj bezgalīgi

Kļūdu apstrāde

async function checkStatusWithRetry(messageId, apiKey, retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      const response = await fetch(
        `https://restapi.smsbat.com/bat/message/${messageId}`,
        {
          headers: { 'X-Authorization-Key': apiKey }
        }
      );

      if (!response.ok) {
        throw new Error(`HTTP ${response.status}`);
      }

      return await response.json();
    } catch (error) {
      if (i === retries - 1) throw error;

      // Wait before retry (exponential backoff)
      await new Promise(resolve =>
        setTimeout(resolve, Math.pow(2, i) * 1000)
      );
    }
  }
}

Kešatmiņa

Kešatmiņas statusa rezultāti, lai samazinātu API zvanu skaitu:

const statusCache = new Map();

async function getCachedStatus(messageId, apiKey, cacheTTL = 30000) {
  const cached = statusCache.get(messageId);

  if (cached && Date.now() - cached.timestamp < cacheTTL) {
    return cached.status;
  }

  const status = await checkStatus(messageId, apiKey);

  statusCache.set(messageId, {
    status,
    timestamp: Date.now()
  });

  return status;
}

Pakešu apstrāde

Pārbaudot daudzus ziņojumus, pakešu pieprasījumi:

async function checkBatchStatus(messageIds, apiKey, batchSize = 10) {
  const results = [];

  for (let i = 0; i < messageIds.length; i += batchSize) {
    const batch = messageIds.slice(i, i + batchSize);
    const batchResults = await Promise.all(
      batch.map(id => checkStatus(id, apiKey))
    );
    results.push(...batchResults);

    // Rate limiting
    if (i + batchSize < messageIds.length) {
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
  }

  return results;
}

Lietošanas gadījumi

Pasūtījuma apstiprinājums

Izsekojiet pasūtījuma apstiprinājuma ziņojumu piegādi:

const orderMessage = await sendMessage({
  to: customer.phone,
  text: `Order #${orderId} confirmed`
});

// Wait for delivery
const result = await waitForDelivery(orderMessage.messageId, apiKey);

if (result.success) {
  await updateOrder(orderId, { notificationSent: true });
} else {
  await scheduleRetry(orderId);
}

Divu faktoru autentifikācija

Pārbaudiet OTP piegādi pirms taimauta:

const otpMessage = await sendOTP(userPhone, otpCode);

// Poll for delivery
const delivered = await waitForDelivery(
  otpMessage.messageId,
  apiKey,
  30 // 30 second timeout
);

if (!delivered.success) {
  // Send via alternative channel
  await sendEmailOTP(userEmail, otpCode);
}

Mārketinga kampaņas

Izsekojiet kampaņas ziņojumu piegādes tarifus:

const messageIds = await sendCampaign(recipientList);

// Check all statuses after 5 minutes
setTimeout(async () => {
  const statuses = await checkBatchStatus(messageIds, apiKey);

  const delivered = statuses.filter(s =>
    s.deliverystatus === 'delivered'
  ).length;

  console.log(`Delivery rate: ${delivered / statuses.length * 100}%`);
}, 5 * 60 * 1000);

Nākamie soļi