ChinqIT Verify

https://docs.sms.chinqit.com
Admin
Chinqit Verify is a REST API gateway for sending SMS messages and OTP codes with comprehensive...
Tokens:26,216
Snippets:229
Trust Score:4.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install react-native-sms-retriever

Source: https://docs.sms.chinqit.com/sms-retriever-guide

Commands to install the package using npm or yarn.

```bash
npm install react-native-sms-retriever
# ou
yarn add react-native-sms-retriever
```

--------------------------------

### cURL Request Example

Source: https://docs.sms.chinqit.com/api-v2

Example of how to trigger an OTP request using cURL.

```bash
curl -X POST https://sms.chinqit.com/api/v2/code \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"phoneNumber": "+22238089336", "language": "en"}'
```

--------------------------------

### GET /api/v2/webhooks

Source: https://docs.sms.chinqit.com/webhooks

Lists all webhook endpoints configured for the account.

```APIDOC
## GET /api/v2/webhooks

### Description
Retrieves a list of all webhook endpoints associated with the account.

### Method
GET

### Endpoint
/api/v2/webhooks
```

--------------------------------

### Link iOS dependencies

Source: https://docs.sms.chinqit.com/sms-retriever-guide

Command to install CocoaPods for older React Native versions.

```bash
cd ios && pod install
```

--------------------------------

### Verify OTP via cURL

Source: https://docs.sms.chinqit.com/api-v2

Example request to verify an OTP code using cURL.

```bash
curl -X POST https://sms.chinqit.com/api/v2/check \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"phoneNumber": "+22238089336", "otp": "123456"}'
```

--------------------------------

### Deprecation response format

Source: https://docs.sms.chinqit.com/api-reference

Example response from a deprecated endpoint indicating the recommended replacement.

```json
{
  "success": true,
  "messageId": "550e8400-e29b-41d4-a716-446655440000",
  "queued": true,
  "deprecation": {
    "message": "This endpoint is deprecated. Use POST /api/v2/notify instead.",
    "useInstead": "POST /api/v2/notify"
  }
}
```

--------------------------------

### Get Message Status via cURL

Source: https://docs.sms.chinqit.com/api-v2

Example request to retrieve the status of a specific message using its ID.

```bash
curl -H "X-API-Key: YOUR_API_KEY" \
  "https://sms.chinqit.com/api/v2/notify/550e8400-e29b-41d4-a716-446655440000"
```

--------------------------------

### GET /api/v2/notify/

Source: https://docs.sms.chinqit.com/api-v2

Retrieves the status of a notification.

```APIDOC
## GET /api/v2/notify/

### Description
Retrieves the status of a notification.

### Method
GET

### Endpoint
/api/v2/notify/
```

--------------------------------

### Send SMS via cURL

Source: https://docs.sms.chinqit.com/api-v2

Example command to send an SMS using the POST /api/v2/notify endpoint.

```bash
curl -X POST https://sms.chinqit.com/api/v2/notify \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"phoneNumber": "+22238089336", "message": "Bonjour"}'
```

--------------------------------

### GET /api/v2/bulk/status/

Source: https://docs.sms.chinqit.com/bulk-sms

Retrieves the current status and detailed information of a bulk SMS batch.

```APIDOC
## GET /api/v2/bulk/status/

### Description
Retrieves the status of a bulk SMS batch using the batch ID.

### Method
GET

### Endpoint
/api/v2/bulk/status/

### Parameters
#### Query Parameters
- **batchId** (string) - Required - ID of the batch returned by the sending request.

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the request was successful.
- **batch** (object) - Contains batch details including status, counts, and individual message statuses.

#### Response Example
{
  "success": true,
  "batch": {
    "batchId": "550e8400-e29b-41d4-a716-446655440000",
    "status": "processing",
    "totalMessages": 100,
    "validMessages": 98,
    "invalidCount": 2,
    "successfulCount": 45,
    "failedCount": 5,
    "totalCost": 1.96,
    "progress": 51,
    "createdAt": "2024-01-15T10:30:00.000Z",
    "updatedAt": "2024-01-15T10:31:30.000Z",
    "messages": [
      {
        "messageId": "msg-123",
        "phone": "+22238089336",
        "status": "sent"
      },
      {
        "messageId": "msg-124",
        "phone": "+22238089337",
        "status": "failed",
        "error": "Invalid destination address"
      }
    ]
  }
}
```

--------------------------------

### Implémentation de la logique de nouvelle tentative avec backoff exponentiel

Source: https://docs.sms.chinqit.com/troubleshooting

Utilisez cette classe pour gérer les erreurs temporaires (5xx) et réseau lors de l'envoi d'OTP. Elle inclut une méthode de backoff exponentiel pour espacer les tentatives.

```javascript
class OTPService {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = "https://sms.chinqit.com/api/v2";
  }

  async sendOTPWithRetry(
    phoneNumber,
    language = "fr",
    channel = "sms",
    maxRetries = 3,
  ) {
    let lastError;

    for (let attempt = 0; attempt <= maxRetries; attempt++) {
      try {
        const response = await this.sendOTP(phoneNumber, language, channel);

        if (response.success) {
          return response;
        }

        // Si c'est une erreur 5xx ou réseau, retenter
        if (this.isRetryableError(response)) {
          if (attempt < maxRetries) {
            const delay = Math.pow(2, attempt) * 1000; // Backoff exponentiel
            await this.sleep(delay);
            continue;
          }
        }

        return response; // Erreur non retry-able
      } catch (error) {
        lastError = error;

        // Erreurs réseau ou 5xx sont retry-ables
        if (this.isRetryableNetworkError(error) && attempt < maxRetries) {
          const delay = Math.pow(2, attempt) * 1000;
          await this.sleep(delay);
          continue;
        }

        throw error;
      }
    }

    throw lastError;
  }

  isRetryableError(response) {
    // Erreurs temporaires du serveur
    return response.status >= 500 && response.status < 600;
  }

  isRetryableNetworkError(error) {
    return (
      error.code === "ECONNRESET" ||
      error.code === "ETIMEDOUT" ||
      error.code === "ENOTFOUND"
    );
  }

  async sendOTP(phoneNumber, language, channel) {
    const response = await fetch(`${this.baseURL}/code`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "X-API-Key": this.apiKey,
      },
      body: JSON.stringify({
        phoneNumber,
        language,
        channel,
      }),
    });

    return response.json();
  }

  sleep(ms) {
    return new Promise((resolve) => setTimeout(resolve, ms));
  }
}

// Utilisation
const otpService = new OTPService("YOUR_API_KEY");

try {
  const result = await otpService.sendOTPWithRetry("+22238089336", "fr", "sms");
  console.log("OTP envoyé avec succès:", result.messageId);
} catch (error) {
  console.error("Échec définitif de l'envoi OTP:", error.message);
}
```

--------------------------------

### Implémenter un délai d'attente avec AbortController

Source: https://docs.sms.chinqit.com/troubleshooting

Utilisez AbortController pour interrompre les requêtes fetch dépassant une durée définie, évitant ainsi les blocages prolongés.

```javascript
const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), 10000); // Délai de 10 secondes

try {
  const response = await fetch("https://sms.chinqit.com/api/v2/notify", {
    signal: controller.signal,
    // ... autres options
  });
  clearTimeout(timeoutId);
} catch (error) {
  if (error.name === "AbortError") {
    console.error("Request timeout");
  }
}
```

--------------------------------

### GET /message/:messageId/status

Source: https://docs.sms.chinqit.com/api-reference

Retrieves the delivery status of a message associated with your API key. This endpoint is deprecated; please use GET /api/v2/notify/ instead.

```APIDOC
## GET /message/:messageId/status

### Description
Retrieves the delivery status of a message associated with your API key. This endpoint is deprecated.

### Method
GET

### Endpoint
/message/:messageId/status

### Parameters
#### Path Parameters
- **messageId** (string) - Required - The unique identifier of the message.
```

--------------------------------

### Implémentation de la classe OTPVerificationManager

Source: https://docs.sms.chinqit.com/troubleshooting

Classe gérant les tentatives de livraison automatique d'OTP avec un mécanisme de repli manuel et la vérification via API.

```javascript
class OTPVerificationManager {
  constructor() {
    this.deliveryAttempts = 0;
    this.maxDeliveryAttempts = 2;
    this.manualEntryEnabled = false;
  }

  async requestOTP(phoneNumber, language = "fr") {
    this.deliveryAttempts = 0;
    this.manualEntryEnabled = false;

    // Essayer la livraison automatique d'abord
    while (this.deliveryAttempts < this.maxDeliveryAttempts) {
      try {
        this.deliveryAttempts++;
        console.log(
          `Tentative de livraison ${this.deliveryAttempts}/${this.maxDeliveryAttempts}`,
        );

        const result = await this.attemptDelivery(phoneNumber, language);

        if (result.success) {
          return {
            success: true,
            method: "automatic",
            messageId: result.messageId,
            channel: result.channelUsed,
            expiresIn: result.expiresIn,
          };
        }

        // Si échec et c'était la dernière tentative, activer la saisie manuelle
        if (this.deliveryAttempts >= this.maxDeliveryAttempts) {
          console.log(
            "Livraison automatique échouée, activation de la saisie manuelle",
          );
          this.manualEntryEnabled = true;
          return {
            success: false,
            method: "manual_required",
            reason: "delivery_failed",
            message: "Veuillez saisir manuellement le code OTP reçu",
          };
        }

        // Attendre avant la prochaine tentative
        await this.sleep(2000);
      } catch (error) {
        console.error(
          `Tentative ${this.deliveryAttempts} échouée:`,
          error.message,
        );

        if (this.deliveryAttempts >= this.maxDeliveryAttempts) {
          this.manualEntryEnabled = true;
          return {
            success: false,
            method: "manual_required",
            reason: "delivery_error",
            message:
              "Erreur de livraison, veuillez saisir manuellement le code OTP",
          };
        }

        await this.sleep(2000);
      }
    }
  }

  async attemptDelivery(phoneNumber, language) {
    // Utiliser la logique de fallback canal précédente
    return await sendOTPWithChannelFallback(phoneNumber, language);
  }

  async verifyOTP(phoneNumber, otp, channel = null) {
    try {
      const response = await fetch("https://sms.chinqit.com/api/v2/check", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "X-API-Key": "YOUR_API_KEY",
        },
        body: JSON.stringify({
          phoneNumber,
          otp,
          ...(channel && { channel }),
        }),
      });

      const result = await response.json();
      return result;
    } catch (error) {
      throw new Error(`Erreur de vérification: ${error.message}`);
    }
  }

  isManualEntryEnabled() {
    return this.manualEntryEnabled;
  }

  sleep(ms) {
    return new Promise((resolve) => setTimeout(resolve, ms));
  }
}

// Exemple d'utilisation dans une interface utilisateur
async function handleOTPRequest(phoneNumber) {
  const manager = new OTPVerificationManager();

  // Afficher un indicateur de chargement
  showLoadingSpinner();

  try {
    const result = await manager.requestOTP(phoneNumber);

    hideLoadingSpinner();

    if (result.success) {
      // Livraison automatique réussie
      showSuccessMessage(`Code envoyé via ${result.channel}`);
      showOTPInputField();
    } else if (result.method === "manual_required") {
      // Activer le mode saisie manuelle
      showManualEntryMode();
      showInfoMessage(result.message);

      // Optionnellement, permettre à l'utilisateur de demander un nouveau code
      showResendButton();
    }
  } catch (error) {
    hideLoadingSpinner();
    showErrorMessage("Erreur lors de l'envoi du code. Veuillez réessayer.");
  }
}

async function handleOTPVerification(phoneNumber, otp) {
  const manager = new OTPVerificationManager();

  try {
    const result = await manager.verifyOTP(phoneNumber, otp);

    if (result.success) {
      showSuccessMessage("Vérification réussie !");
      proceedToNextStep();
    } else {
      if (result.retriesLeft > 0) {
        showErrorMessage(
          `Code incorrect. ${result.retriesLeft} tentatives restantes.`,
        );
      } else {
        showErrorMessage("Code incorrect. Demandez un nouveau code.");
        showResendButton();
      }
    }
  } catch (error) {
    showErrorMessage("Erreur de vérification. Veuillez réessayer.");
  }
}
```

--------------------------------

### Implémentation de la classe OTPMetrics

Source: https://docs.sms.chinqit.com/troubleshooting

Classe permettant de suivre les tentatives de livraison, les canaux utilisés et les performances globales. Utilisez recordAttempt pour enregistrer chaque envoi et logMetrics pour afficher les statistiques.

```javascript
class OTPMetrics {
  constructor() {
    this.metrics = {
      totalRequests: 0,
      successfulDeliveries: 0,
      failedDeliveries: 0,
      channelUsage: { sms: 0, whatsapp: 0 },
      fallbackUsage: 0,
      manualEntryUsage: 0,
      averageDeliveryTime: 0,
    };
  }

  recordAttempt(channel, success, deliveryTime = null) {
    this.metrics.totalRequests++;

    if (success) {
      this.metrics.successfulDeliveries++;
    } else {
      this.metrics.failedDeliveries++;
    }

    this.metrics.channelUsage[channel] =
      (this.metrics.channelUsage[channel] || 0) + 1;

    if (deliveryTime) {
      this.metrics.averageDeliveryTime =
        (this.metrics.averageDeliveryTime + deliveryTime) / 2;
    }
  }

  recordFallback() {
    this.metrics.fallbackUsage++;
  }

  recordManualEntry() {
    this.metrics.manualEntryUsage++;
  }

  getSuccessRate() {
    return this.metrics.totalRequests > 0
      ? (this.metrics.successfulDeliveries / this.metrics.totalRequests) * 100
      : 0;
  }

  getChannelPreference() {
    const smsRate = this.metrics.channelUsage.sms || 0;
    const whatsappRate = this.metrics.channelUsage.whatsapp || 0;
    const total = smsRate + whatsappRate;

    return total > 0
      ? {
          sms: (smsRate / total) * 100,
          whatsapp: (whatsappRate / total) * 100,
        }
      : { sms: 0, whatsapp: 0 };
  }

  logMetrics() {
    console.log("OTP Delivery Metrics:");
    console.log(`- Total requests: ${this.metrics.totalRequests}`);
    console.log(`- Success rate: ${this.getSuccessRate().toFixed(2)}%`);
    console.log(`- Channel usage:`, this.getChannelPreference());
    console.log(`- Fallback usage: ${this.metrics.fallbackUsage}`);
    console.log(`- Manual entry usage: ${this.metrics.manualEntryUsage}`);
    console.log(
      `- Avg delivery time: ${this.metrics.averageDeliveryTime.toFixed(2)}ms`,
    );
  }
}

// Utilisation
const metrics = new OTPMetrics();

// Après chaque tentative de livraison
metrics.recordAttempt("sms", true, 2500);
metrics.recordFallback();
metrics.recordManualEntry();

// Afficher les métriques périodiquement
setInterval(() => metrics.logMetrics(), 3600000); // Toutes les heures
```

--------------------------------

### GET /api/v2/webhooks/{id}/deliveries

Source: https://docs.sms.chinqit.com/webhooks

Retrieves the delivery history for a webhook.

```APIDOC
## GET /api/v2/webhooks/{id}/deliveries

### Description
Fetches the history of delivery attempts for a specific webhook.

### Method
GET

### Endpoint
/api/v2/webhooks/{id}/deliveries

### Parameters
#### Path Parameters
- **id** (string) - Required - The unique identifier of the webhook.
```

--------------------------------

### Vérifier l'en-tête X-API-Key avec cURL

Source: https://docs.sms.chinqit.com/troubleshooting

Utilisez l'en-tête X-API-Key sensible à la casse pour authentifier vos requêtes.

```bash
# Doit être exactement : X-API-Key (sensible à la casse)
curl -H "X-API-Key: your-key" https://sms.chinqit.com/api/v2/notify
```

--------------------------------

### Créer un endpoint webhook via cURL

Source: https://docs.sms.chinqit.com/webhooks

Utilisez cette requête pour enregistrer une nouvelle URL de réception d'événements. L'en-tête X-API-Key est obligatoire pour l'authentification.

```bash
curl -X POST https://sms.chinqit.com/api/v2/webhooks \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/webhooks/chinqit",
    "events": ["message.sent", "message.failed", "otp.verified"]
  }'
```

--------------------------------

### GET /api/v2/webhooks/{id}

Source: https://docs.sms.chinqit.com/webhooks

Retrieves details for a specific webhook endpoint.

```APIDOC
## GET /api/v2/webhooks/{id}

### Description
Fetches the configuration details for a specific webhook endpoint by its ID.

### Method
GET

### Endpoint
/api/v2/webhooks/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - The unique identifier of the webhook.
```

--------------------------------

### GET /api/v2/notify/{messageId}

Source: https://docs.sms.chinqit.com/api-v2

Retrieves the delivery status and details of a specific message.

```APIDOC
## GET /api/v2/notify/{messageId}

### Description
Obtains the delivery status of a message. Returns 404 if the message is not found or does not belong to the API key.

### Method
GET

### Endpoint
/api/v2/notify/{messageId}

### Parameters
#### Path Parameters
- **messageId** (string) - Required - The unique identifier of the message.

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the operation was successful.
- **data** (object) - Contains message details including status, channel, and timestamps.

#### Response Example
{
  "success": true,
  "data": {
    "messageId": "550e8400-e29b-41d4-a716-446655440000",
    "status": "sent",
    "billed": true,
    "phoneNumber": "+22238089336",
    "channel": "sms",
    "dlrStatus": "DELIVRD"
  }
}
```

--------------------------------

### Implémentation d'un délai d'attente exponentiel

Source: https://docs.sms.chinqit.com/troubleshooting

Fonction asynchrone pour gérer les erreurs 429 en réessayant la requête avec un délai exponentiel.

```javascript
async function sendOTPWithRetry(
  phoneNumber,
  language,
  channel,
  maxRetries = 3,
) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await client.sendOTP(phoneNumber, language, channel);
    } catch (error) {
      if (error.status === 429 && i < maxRetries - 1) {
        // Attendre avec délai exponentiel
        const waitTime = Math.pow(2, i) * 1000; // 1s, 2s, 4s
        await new Promise((resolve) => setTimeout(resolve, waitTime));
        continue;
      }
      throw error;
    }
  }
}
```

--------------------------------

### Implémenter le basculement automatique entre canaux

Source: https://docs.sms.chinqit.com/troubleshooting

Utilisez cette fonction asynchrone pour tenter l'envoi d'un OTP via un canal primaire, avec une bascule automatique vers le canal secondaire en cas d'échec.

```javascript
async function sendOTPWithChannelFallback(
  phoneNumber,
  language = "fr",
  primaryChannel = "sms",
) {
  const channels =
    primaryChannel === "sms" ? ["sms", "whatsapp"] : ["whatsapp", "sms"];

  for (const channel of channels) {
    try {
      console.log(`Tentative d'envoi OTP via ${channel}...`);

      const response = await fetch("https://sms.chinqit.com/api/v2/code", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "X-API-Key": "YOUR_API_KEY",
        },
        body: JSON.stringify({
          phoneNumber,
          language,
          channel,
        }),
      });

      const result = await response.json();

      if (result.success) {
        console.log(`OTP envoyé avec succès via ${channel}`);
        return {
          ...result,
          channelUsed: channel,
        };
      }

      // Si échec définitif (pas d'erreur temporaire), essayer l'autre canal
      if (!isTemporaryFailure(result)) {
        console.log(
          `${channel} a échoué définitivement, essai de l'autre canal...`,
        );
        continue;
      }

      // Erreur temporaire, ne pas essayer l'autre canal immédiatement
      throw new Error(
        `${channel} temporairement indisponible: ${result.message}`,
      );
    } catch (error) {
      console.error(`Erreur avec ${channel}:`, error.message);

      // Continuer vers l'autre canal seulement si c'est le premier essai
      if (channel === channels[0]) {
        continue;
      }

      throw error;
    }
  }

  throw new Error("Les deux canaux ont échoué");
}

function isTemporaryFailure(result) {
  // Considérer comme temporaire les erreurs 5xx ou certains messages spécifiques
  return (
    result.status >= 500 ||
    result.message?.includes("temporarily unavailable") ||
    result.message?.includes("service unavailable")
  );
}

// Utilisation
try {
  const result = await sendOTPWithChannelFallback("+22238089336", "fr", "sms");
  console.log(`OTP envoyé via ${result.channelUsed}:`, result.messageId);
} catch (error) {
  console.error("Échec sur les deux canaux:", error.message);
}
```

--------------------------------

### Implémenter un repli vers SMS pour l'envoi d'OTP

Source: https://docs.sms.chinqit.com/troubleshooting

Utilisez cette fonction pour tenter un envoi via WhatsApp et basculer automatiquement vers SMS en cas d'erreur 502 Bad Gateway.

```javascript
async function sendOTPWithFallback(phoneNumber, language) {
  try {
    // Essayer WhatsApp en premier
    return await client.sendOTP(phoneNumber, language, "whatsapp");
  } catch (error) {
    if (error.status === 502) {
      // Repli vers SMS si WhatsApp échoue
      console.log("WhatsApp failed, falling back to SMS");
      return await client.sendOTP(phoneNumber, language, "sms");
    }
    throw error;
  }
}
```

--------------------------------

### Ajouter la dépendance sms_autofill

Source: https://docs.sms.chinqit.com/sms-retriever-guide

Ajoutez cette ligne dans votre fichier pubspec.yaml pour utiliser le package sms_autofill.

```yaml
dependencies:
  sms_autofill: ^2.3.0
```

--------------------------------

### GET /api/analytics/summary

Source: https://docs.sms.chinqit.com/analytics-dashboard

Retrieves a summary of analytics data based on the specified time range.

```APIDOC
## GET /api/analytics/summary

### Description
Retrieves analytics summary data for the dashboard. This endpoint replaces all legacy analytics endpoints.

### Method
GET

### Endpoint
/api/analytics/summary

### Parameters
#### Query Parameters
- **range** (integer) - Optional - The time range in days. Accepts 7, 30, or 90. Defaults to 30 if any other value is provided.
```

--------------------------------

### Get App Signature with react-native-sms-retriever

Source: https://docs.sms.chinqit.com/sms-retriever-guide

Retrieves the unique application hash required for SMS verification.

```javascript
import SmsRetriever from "react-native-sms-retriever";

class SmsRetrieverExample {
  async getAppSignature() {
    try {
      const hash = await SmsRetriever.getAppHash();
      return hash;
    } catch (error) {
      console.error("Erreur lors de l'obtention du hash de l'application :", error);
      return null;
    }
  }
}
```

--------------------------------

### Exemple d'événement bulk.completed

Source: https://docs.sms.chinqit.com/webhooks

Notification émise à la fin du traitement d'une tâche d'envoi en masse.

```json
{
  "id": "evt_01j9z...",
  "type": "bulk.completed",
  "createdAt": "2026-06-27T10:05:00.000Z",
  "data": {
    "batchId": "batch_01j9z...",
    "status": "completed",
    "totalMessages": 1000,
    "successfulCount": 985,
    "failedCount": 12,
    "invalidCount": 3,
    "totalCost": 9.85
  }
}
```

--------------------------------

### Get Message Status Response

Source: https://docs.sms.chinqit.com/api-v2

Response structures for successful delivery and failed delivery scenarios.

```json
{
  "success": true,
  "data": {
    "messageId": "550e8400-e29b-41d4-a716-446655440000",
    "status": "sent",
    "billed": true,
    "sent": true,
    "phoneNumber": "+22238089336",
    "type": "message",
    "channel": "sms",
    "smppMessageId": "abc123",
    "submittedAt": "2024-01-15T10:30:00.000Z",
    "dlrStatus": "DELIVRD",
    "dlrReceivedAt": "2024-01-15T10:30:05.000Z",
    "providerError": null,
    "createdAt": "2024-01-15T10:29:55.000Z",
    "updatedAt": "2024-01-15T10:30:05.000Z"
  }
}
```

```json
{
  "success": true,
  "data": {
    "messageId": "550e8400-e29b-41d4-a716-446655440000",
    "status": "failed",
    "billed": false,
    "sent": false,
    "phoneNumber": "+22238089336",
    "type": "message",
    "channel": "sms",
    "providerError": {
      "code": "NO_CREDIT",
      "message": "Insufficient balance",
      "statusCode": 402
    },
    "createdAt": "2024-01-15T10:29:55.000Z",
    "updatedAt": "2024-01-15T10:29:56.000Z"
  }
}
```

--------------------------------

### GET /api/v2/bulk/status/{batchId}

Source: https://docs.sms.chinqit.com/bulk-sms

Retrieves the processing status of a previously submitted bulk SMS batch.

```APIDOC
## GET /api/v2/bulk/status/{batchId}

### Description
Interrogate the status endpoint to track the delivery progress of a bulk SMS batch.

### Method
GET

### Endpoint
https://sms.chinqit.com/api/v2/bulk/status/{batchId}

### Parameters
#### Path Parameters
- **batchId** (string) - Required - The unique identifier of the bulk SMS batch.

### Response
#### Success Response (200)
- **batch.status** (string) - The current status of the batch (e.g., 'completed', 'failed', 'partial').
- **batch.progress** (number) - The completion percentage of the batch.
```

--------------------------------

### Vérifier le format de la clé API

Source: https://docs.sms.chinqit.com/troubleshooting

Assurez-vous que la clé API ne contient pas d'espaces ou de caractères de saut de ligne.

```bash
# Assurez-vous qu'il n'y a pas d'espaces ou de caractères supplémentaires
# Correct : "abc123xyz"
# Incorrect : " abc123xyz " ou "abc123xyz\n"
```

--------------------------------

### Send Bulk SMS Request

Source: https://docs.sms.chinqit.com/bulk-sms

Example JSON payload for sending personalized messages to multiple recipients.

```json
{
  "recipients": [
    {
      "phone": "+22238089336",
      "message": "Bonjour Jean, votre commande est prête !"
    },
    {
      "phone": "+22238089337",
      "message": "Bonjour Sarah, votre commande est prête !"
    }
  ]
}
```

--------------------------------

### Exemple de réponse pour le statut d'un lot

Source: https://docs.sms.chinqit.com/bulk-sms

Structure JSON retournée lors de la consultation du statut d'un lot d'envoi, incluant les détails de progression et les statuts individuels des messages.

```json
{
  "success": true,
  "batch": {
    "batchId": "550e8400-e29b-41d4-a716-446655440000",
    "status": "processing",
    "totalMessages": 100,
    "validMessages": 98,
    "invalidCount": 2,
    "successfulCount": 45,
    "failedCount": 5,
    "totalCost": 1.96,
    "progress": 51,
    "createdAt": "2024-01-15T10:30:00.000Z",
    "updatedAt": "2024-01-15T10:31:30.000Z",
    "messages": [
      {
        "messageId": "msg-123",
        "phone": "+22238089336",
        "status": "sent"
      },
      {
        "messageId": "msg-124",
        "phone": "+22238089337",
        "status": "failed",
        "error": "Invalid destination address"
      }
    ]
  }
}
```

--------------------------------

### Exemple d'événement message.failed

Source: https://docs.sms.chinqit.com/webhooks

Notification émise lorsqu'un message n'a pas pu être soumis à l'opérateur.

```json
{
  "id": "evt_01j9z...",
  "type": "message.failed",
  "createdAt": "2026-06-27T10:00:05.000Z",
  "data": {
    "messageId": "550e8400-e29b-41d4-a716-446655440000",
    "phoneNumber": "+22238089336",
    "senderId": "CHINQIT",
    "channel": "sms",
    "type": "message",
    "failureReason": "Insufficient balance"
  }
}
```

--------------------------------

### Exemple d'événement otp.verified

Source: https://docs.sms.chinqit.com/webhooks

Notification émise lorsqu'un utilisateur final saisit le code OTP correct.

```json
{
  "id": "evt_01j9z...",
  "type": "otp.verified",
  "createdAt": "2026-06-27T10:02:00.000Z",
  "data": {
    "messageId": "550e8400-e29b-41d4-a716-446655440000",
    "phoneNumber": "+22238089336",
    "verifiedAt": "2026-06-27T10:02:00.000Z"
  }
}
```

--------------------------------

### Implémentation d'un limiteur de débit OTP

Source: https://docs.sms.chinqit.com/troubleshooting

Classe permettant de suivre les requêtes par numéro de téléphone et de vérifier si l'envoi est autorisé selon des quotas définis.

```javascript
class OTPRateLimiter {
  constructor(maxRequestsPerMinute = 10, maxRequestsPerHour = 50) {
    this.requests = [];
    this.maxPerMinute = maxRequestsPerMinute;
    this.maxPerHour = maxRequestsPerHour;
  }

  canSend(phoneNumber) {
    const now = Date.now();
    const oneMinuteAgo = now - 60000;
    const oneHourAgo = now - 3600000;

    // Nettoyer les anciennes requêtes
    this.requests = this.requests.filter((req) => req.timestamp > oneHourAgo);

    // Compter les requêtes pour ce numéro
    const recentRequests = this.requests.filter(
      (req) => req.phoneNumber === phoneNumber && req.timestamp > oneMinuteAgo,
    );

    const hourlyRequests = this.requests.filter(
      (req) => req.phoneNumber === phoneNumber && req.timestamp > oneHourAgo,
    );

    return (
      recentRequests.length < this.maxPerMinute &&
      hourlyRequests.length < this.maxPerHour
    );
  }

  recordRequest(phoneNumber) {
    this.requests.push({
      phoneNumber,
      timestamp: Date.now(),
    });
  }

  getTimeUntilNextAllowed(phoneNumber) {
    if (this.canSend(phoneNumber)) {
      return 0;
    }

    const now = Date.now();
    const recentRequests = this.requests
      .filter((req) => req.phoneNumber === phoneNumber)
      .sort((a, b) => b.timestamp - a.timestamp);

    if (recentRequests.length >= this.maxPerMinute) {
      const oldestRecent = recentRequests[this.maxPerMinute - 1];
      return Math.max(0, 60000 - (now - oldestRecent.timestamp));
    }

    return 0;
  }
}

// Intégration avec le service OTP
async function sendOTPWithRateLimit(phoneNumber, language) {
  const rateLimiter = new OTPRateLimiter();

  if (!rateLimiter.canSend(phoneNumber)) {
    const waitTime = rateLimiter.getTimeUntilNextAllowed(phoneNumber);
    throw new Error(
      `Trop de requêtes. Réessayez dans ${Math.ceil(waitTime / 1000)} secondes.`,
    );
  }

  try {
    const result = await sendOTPWithChannelFallback(phoneNumber, language);
    rateLimiter.recordRequest(phoneNumber);
    return result;
  } catch (error) {
    // Ne pas compter les échecs réseau comme des requêtes réussies
    throw error;
  }
}
```

--------------------------------

### POST /api/v2/code

Source: https://docs.sms.chinqit.com/api-v2

Initiates an OTP code request via SMS or WhatsApp.

```APIDOC
## POST /api/v2/code

### Description
Initiates an OTP code request. The channel parameter determines if the code is sent via SMS or WhatsApp.

### Method
POST

### Endpoint
/api/v2/code
```

--------------------------------

### Structure de l'enveloppe d'événement

Source: https://docs.sms.chinqit.com/webhooks

Format standard utilisé pour toutes les notifications envoyées par les webhooks.

```json
{
  "id": "evt_01j9z...",
  "type": "message.sent",
  "createdAt": "2026-06-27T10:00:00.000Z",
  "data": { ... }
}
```

--------------------------------

### Send Bulk SMS with cURL

Source: https://docs.sms.chinqit.com/bulk-sms

Executes a POST request directly from the command line.

```bash
curl -X POST https://sms.chinqit.com/api/v2/bulk/send \
  -H "Content-Type: application/json" \
  -H "X-API-Key: your_api_key_here" \
  -d '{
    "recipients": [
      {"phone": "+22238089336", "message": "Bonjour !"},
      {"phone": "+22238089337", "message": "Salut !"}
    ]
  }'
```

--------------------------------

### Tester la connectivité API avec cURL

Source: https://docs.sms.chinqit.com/troubleshooting

Utilisez cURL pour vérifier rapidement la connectivité et l'authentification avec le point de terminaison de l'API.

```bash
# Tester la connectivité de base
curl -X POST https://sms.chinqit.com/api/v2/notify \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"phoneNumber": "+1234567890", "message": "Test"}'
```

--------------------------------

### Récupération des statistiques analytiques

Source: https://docs.sms.chinqit.com/analytics-dashboard

Appel de la route API interne Next.js pour obtenir un résumé des données sur une période définie.

```http
GET /api/analytics/summary?range=7|30|90
```

--------------------------------

### Use react-native-otp-verify

Source: https://docs.sms.chinqit.com/sms-retriever-guide

Alternative implementation for SMS retrieval using the react-native-otp-verify library.

```bash
npm install react-native-otp-verify
```

```javascript
import OtpVerify from "react-native-otp-verify";

// Obtenir le hash
OtpVerify.getHash()
  .then((hash) => {
    console.log("Hash :", hash);
  })
  .catch((error) => {
    console.error("Erreur :", error);
  });

// Écouter les SMS
OtpVerify.getOtp()
  .then((message) => {
    // Extraire l'OTP du message
    const otp = extractOtp(message);
    verifyOtp(otp);
  })
  .catch((error) => {
    console.error("Erreur :", error);
  });
```

--------------------------------

### POST /api/v2/webhooks

Source: https://docs.sms.chinqit.com/webhooks

Creates a new webhook endpoint to receive specified events.

```APIDOC
## POST /api/v2/webhooks

### Description
Creates a new webhook endpoint to receive events from the ChinqIT system.

### Method
POST

### Endpoint
/api/v2/webhooks

### Request Body
- **url** (string) - Required - The public HTTPS endpoint to receive events.
- **events** (array) - Required - List of event types to subscribe to.
- **apiKeyIds** (array) - Optional - Restrict events to specific API keys.

### Request Example
{
  "url": "https://example.com/webhooks/chinqit",
  "events": ["message.sent", "message.failed", "otp.verified"]
}

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the operation was successful.
- **webhook** (object) - The created webhook configuration.
- **secret** (string) - The full secret used for signing payloads.
```

--------------------------------

### Vérification de signature en Node.js

Source: https://docs.sms.chinqit.com/webhooks

Implémentation complète pour valider la signature X-Chinqit-Signature et vérifier l'horodatage pour prévenir les attaques par rejeu.

```javascript
import { createHmac, timingSafeEqual } from 'node:crypto';

function verifySignature(secret, rawBody, sigHeader, tsHeader, toleranceSec = 300) {
  const now = Math.floor(Date.now() / 1000);
  const ts = parseInt(tsHeader, 10);
  if (Math.abs(now - ts) > toleranceSec) return false;

  const parts = sigHeader.split(',');
  const t = parts.find(p => p.startsWith('t=')).slice(2);
  const v1s = parts.filter(p => p.startsWith('v1=')).map(p => p.slice(3));

  const expected = createHmac('sha256', secret).update(`${t}.${rawBody}`).digest('hex');
  return v1s.some(v => {
    try { return timingSafeEqual(Buffer.from(v, 'hex'), Buffer.from(expected, 'hex')); }
    catch { return false; }
  });
}
```

--------------------------------

### Écouter les SMS avec sms_autofill

Source: https://docs.sms.chinqit.com/sms-retriever-guide

Implémentez l'écoute des SMS et l'affichage du champ de saisie automatique dans votre interface utilisateur.

```dart
import 'package:sms_autofill/sms_autofill.dart';

class OtpVerificationScreen extends StatefulWidget {
  @override
  _OtpVerificationScreenState createState() => _OtpVerificationScreenState();
}

class _OtpVerificationScreenState extends State<OtpVerificationScreen> {
  String? _code;
  final SmsAutoFill _autoFill = SmsAutoFill();

  @override
  void initState() {
    super.initState();
    _listenForSms();
  }

  void _listenForSms() {
    _autoFill.listenForCode();
  }

  @override
  Widget build(BuildContext context) {
    return PinFieldAutoFill(
      codeLength: 6,
      onCodeSubmitted: (code) {
        setState(() {
          _code = code;
        });
        // Vérifier l'OTP avec votre backend
        _verifyOtp(code);
      },
    );
  }

  Future<void> _verifyOtp(String code) async {
    // Envoyer une requête de vérification à votre backend
    final response = await http.post(
      Uri.parse('https://your-api.com/otp/verify'),
      body: jsonEncode({
        'phoneNumber': '+1234567890',
        'otp': code,
      }),
    );
  }

  @override
  void dispose() {
    _autoFill.unregisterListener();
    super.dispose();
  }
}
```

--------------------------------

### Send OTP Request

Source: https://docs.sms.chinqit.com/api-reference

Request body for initiating an OTP via SMS or WhatsApp.

```json
{
  "phoneNumber": "+22238089336",
  "hash": "ABC123XYZ45",
  "language": "en",
  "channel": "sms"
}
```

--------------------------------

### Structure de la réponse de création de webhook

Source: https://docs.sms.chinqit.com/webhooks

La réponse contient les détails de l'objet webhook créé et le secret complet. Le secret n'est affiché qu'à la création, lors d'une rotation ou d'une révélation.

```json
{
  "success": true,
  "webhook": {
    "_id": "665f1a2b3c4d5e6f7a8b9c0d",
    "userId": "6953a1b2c3d4e5f6a7b8c9d0",
    "url": "https://example.com/webhooks/chinqit",
    "events": ["message.sent", "message.failed", "otp.verified"],
    "status": "enabled",
    "secretPrefix": "whsec_ab12c…",
    "consecutiveFailures": 0,
    "createdAt": "2026-06-27T10:00:00.000Z",
    "updatedAt": "2026-06-27T10:00:00.000Z"
  },
  "secret": "whsec_4f3c8e21a9b0c7d6e5f4a3b2c1d0e9f8a7b6c5d4e3f2a1b0c9d8e7f6a5b4c3d2"
}
```

--------------------------------

### Exemple d'événement message.rejected

Source: https://docs.sms.chinqit.com/webhooks

Notification émise lorsqu'un message est refusé par l'opérateur après réception.

```json
{
  "id": "evt_01j9z...",
  "type": "message.rejected",
  "createdAt": "2026-06-27T10:00:03.000Z",
  "data": {
    "messageId": "550e8400-e29b-41d4-a716-446655440000",
    "phoneNumber": "+22238089336",
    "senderId": "CHINQIT",
    "channel": "sms",
    "type": "message",
    "billed": true
  }
}
```

--------------------------------

### Envoyer un SMS avec hash via ChinqIT

Source: https://docs.sms.chinqit.com/sms-retriever-guide

Envoyez le code OTP incluant le hash de l'application pour permettre la détection automatique.

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

Future<void> sendOtpWithHash(String phoneNumber) async {
  // Obtenir la signature de l'application (hash)
  final signature = await SmsAutoFill().getAppSignature;

  // Envoyer un SMS via l'API ChinqIT Verify
  final response = await http.post(
    Uri.parse('https://sms.chinqit.com/api/v2/notify'),
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': 'YOUR_API_KEY',
    },
    body: jsonEncode({
      'phoneNumber': phoneNumber,
      'message': 'Your verification code is: 123456',
      'hash': signature, // Inclure le hash
    }),
  );

  if (response.statusCode == 200) {
    print('SMS envoyé avec succès');
  }
}
```

--------------------------------

### Utilisation du package sms_retriever

Source: https://docs.sms.chinqit.com/sms-retriever-guide

Configuration et implémentation alternative utilisant le package sms_retriever.

```yaml
dependencies:
  sms_retriever: ^1.0.0
```

```dart
import 'package:sms_retriever/sms_retriever.dart';

Future<String?> getAppSignature() async {
  try {
    final signature = await SmsRetriever.getAppSignature();
    return signature;
  } catch (e) {
    print('Erreur : $e');
    return null;
  }
}

void listenForSms() {
  SmsRetriever.listenForSms().listen((sms) {
    // Extraire l'OTP du SMS
    final otp = extractOtp(sms);
    // Vérifier l'OTP
    verifyOtp(otp);
  });
}

String extractOtp(String sms) {
  // Extraire un OTP de 6 chiffres du SMS
  final regex = RegExp(r'\b\d{6}\b');
  final match = regex.firstMatch(sms);
  return match?.group(0) ?? '';
}
```

--------------------------------

### Obtenir le hash de l'application avec sms_autofill

Source: https://docs.sms.chinqit.com/sms-retriever-guide

Utilisez cette méthode pour récupérer la signature unique de votre application nécessaire à l'auto-remplissage.

```dart
import 'package:sms_autofill/sms_autofill.dart';

class SmsRetrieverExample {
  Future<String?> getAppSignature() async {
    try {
      final signature = await SmsAutoFill().getAppSignature;
      return signature;
    } catch (e) {
      print('Erreur lors de l\'obtention de la signature de l\'application : $e');
      return null;
    }
  }
}
```
Tokens:
Raw