> ## Documentation Index
> Fetch the complete documentation index at: https://docs.hub2.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Intégration

> Apprenez comment intégrer le mode Processing Only dans votre application

## Intégration API

Le mode **ProcessingOnly** utilise des endpoints API HUB2 dédiés qui sont différents de notre modèle d'agrégation traditionnel. La principale différence est que les transactions sont traitées directement via votre compte fournisseur au lieu de nos comptes agrégés.
Les endpoints disponibles sont listés dans la documentation suivante :

<Card title="API Delegation" icon="link" href="https://api.hub2.io/docs#/Delegation" arrow="true" cta="Vers la documentation de l'API Delegation" />

## Authentification

Votre intégration utilise les mêmes clés API HUB2 pour l'authentification mais la clé doit avoir de nouvelles permissions :

* `Api.delegated_payment_create`
* `Api.delegated_transfer_create`

<Card title="Configuration des permissions" icon="link" href="/integration/fr/processing_only/processing_only_setup#configuration-dans-le-tableau-de-bord-hub2" arrow="true" cta="Vers le guide configuration des permissions pour la clé API" />

## Flux de Transaction

### 1. Requête de Transaction

Lorsque vous initiez une transaction, HUB2 va :

1. **Valider la requête** : Vérifier la clé API et le format de la demande
2. **Router vers le Fournisseur** : Diriger la demande vers votre compte fournisseur configuré
3. **Traiter la Transaction** : Exécuter la transaction en utilisant vos identifiants fournisseur
4. **Retourner la Réponse** : Fournir un format de réponse unifié indépendamment du fournisseur

### 2. Traitement Fournisseur

Le traitement réel de la transaction se fait directement avec votre fournisseur :

```mermaid theme={null}
sequenceDiagram
    participant M as Marchand
    participant H as HUB2
    participant P as Fournisseur

    M->>H: Demande de Transaction
    H->>P: Traiter via Compte Marchand
    P->>H: Réponse de Transaction
    H->>M: Réponse Unifiée
```

## Endpoints API

Le mode Processing Only utilise des endpoints de création dédiés, tandis que les endpoints de lecture restent les mêmes que pour le circuit classique :

### Paiements

* `POST /delegated/payments` - Créer un paiement en utilisant votre compte fournisseur
  Contrairement au paiement classique, pas besoin de créer une intention de paiement dans un premier temps, avant une tentative de paiement.
  Ici, vous effectuez directement la tentative de paiement. Ci-après un exemple.

<CodeGroup>
  ```bash Curl {1} theme={null}
  curl --location 'https://api.hub2.io/delegated/payments' \
  --header 'environment: sandbox' \
  --header 'merchantId: [REDACTED]' \
  --header 'Content-Type: application/json' \
  --header 'ApiKey: [REDACTED]' \
  --data '{
      "customerReference": "<YOUR_INTERNAL_CUSTOMER_REFERENCE>",
      "purchaseReference": "<YOUR_INTERNAL_REFERENCE>",
      "amount": 120,
      "currency": "XOF",
      "paymentMethod": "mobile_money",
      "country": "CI",
      "provider": "orange",
      "mobileMoney": {
          "msisdn": "00000001",
          "onCancelRedirectionUrl": "https://failed.com",
          "onFinishRedirectionUrl": "https://success.com",
          "workflow": "redirection"
      }
  }'
  ```
</CodeGroup>

* `POST /delegated/payments/sync` - Créer un paiement en utilisant votre compte fournisseur en mode synchrone (la liste des fournisseurs supportant le mode synchrone est disponible à [https://docs.hub2.io/integration/fr/getting\_started/api\_operation#synchronous-circuit](https://docs.hub2.io/integration/fr/getting_started/api_operation#synchronous-circuit))
* `GET /payments` - Lister les paiements (le même que pour les paiements classiques)
* `GET /payments/{id}/status` - Obtenir le status d'un paiement (le même que pour les paiements classiques)

<Card title="Guide d'intégration des paiements" icon="link" href="/integration/fr/payments/payments_integration" arrow="true" cta="Vers le guide d'intégration des paiements" />

### Transferts

* `POST /delegated/transfers` - Créer un transfert en utilisant votre compte fournisseur. Plus bas un exemple. Seul le endpoint change ici dans la requête.

<CodeGroup>
  ```bash Curl {1} theme={null}
  curl --location --request POST 'https://api.hub2.io/delegated/transfers' \
  --header 'ApiKey: [REDACTED]' \
  --header 'MerchantId: [REDACTED]' \
  --header 'Environment: sandbox' \
  --header 'Content-Type: application/json' \
  --data-raw '{
    "reference": "<YOUR_INTERNAL_REFERENCE>",
    "amount": 2000,
    "currency": "XOF",
    "description": "<YOUR_DESCRIPTION>",
    "destination": {
      "type": "mobile_money",
      "country": "CI",
      "recipientName": "John Doe",
      "msisdn": "+225000000000",
      "provider": "orange"
    }
  }'
  ```

  ```typescript Typescript {4} theme={null}
  import fetch from 'node-fetch';

  async function postTransfer() {
      const response = await fetch('https://api.hub2.io/delegated/transfers', {
          method: 'POST',
          headers: {
              'ApiKey': '[REDACTED]',
              'MerchantId': '[REDACTED]',
              'Environment': 'sandbox',
              'Content-Type': 'application/json'
          },
          body: JSON.stringify({
              "reference": "<YOUR_INTERNAL_REFERENCE>",
              "amount": 2000,
              "currency": "XOF",
              "description": "<YOUR_DESCRIPTION>",
              "destination": {
                  "type": "mobile_money",
                  "country": "CI",
                  "recipientName": "John Doe",
                  "msisdn": "+225000000000",
                  "provider": "orange"
              }
          })
      });

      if (response.ok) {
          const result = await response.json();
          console.log(result);
      } else {
          console.log(`HTTP Status: ${response.status}`);
      }
  }

  postTransfer();
  ```

  ```python Python lines {26} theme={null}
  import json
  import requests

  headers = {
      'ApiKey': '[REDACTED]',
      'MerchantId': '[REDACTED]',
      'Environment': 'sandbox',
      'Content-Type': 'application/json',
  }

  data = {
      "reference": "<YOUR_INTERNAL_REFERENCE>",
      "amount": 2000,
      "currency": "XOF",
      "description": "<YOUR_DESCRIPTION>",
      "destination": {
          "type": "mobile_money",
          "country": "CI",
          "recipientName": "John Doe",
          "msisdn": "+225000000000",
          "provider": "orange"
      }
  }

  response = requests.post(
      'https://api.hub2.io/delegated/transfers',
      headers=headers,
      data=json.dumps(data)
  )

  if response.status_code == 200:
      print(response.json())
  else:
      print(f'HTTP Status: {response.status_code}')
  ```
</CodeGroup>

* `POST /delegated/transfers/irt` - Créer un transfert IRT en utilisant votre compte fournisseur
* `GET /transfers` - Lister les transferts (le même que pour les transferts classiques)
* `GET /transfers/{id}/status` - Obtenir le status d'un transfert (le même que pour les transferts classiques)

<Card title="Guide d'intégration des transferts" icon="link" href="/integration/fr/transfers/transfers_integration" arrow="true" cta="Vers le guide d'intégration des transferts" />

## Webhooks

Ceci utilise les mêmes webhooks que le circuit classique. Si vous avez déjà configuré des webhooks pour les paiements/transferts, aucune étape supplémentaire n'est requise. Sinon, consultez :

<Card title="Guide d'intégration des Webhooks" icon="link" href="https://docs.hub2.io/integration/fr/webhooks/webhooks_overview" arrow="true" cta="Vers le guide d'intégration des Webhooks" />