.NET SDK

Ciblez l'URL de base de l'API la plus à jour

Pour créer des paiements, vous devez lier votre serveur à notre plateforme via l'une de nos méthodes d'intégration.
Notre SDK .NET est la solution idéale pour se connecter à notre plateforme si vous préférez le faire avec votre propre système autonome utilisant le langage C#.

En choisissant le SDK .NET, vous pouvez :

• Accéder à toutes les fonctionnalités de notre API RESTful de manière compacte, pratique et personnalisable.
• Utiliser toutes les méthodes d'intégration côté serveur de notre plateforme (Hosted Checkout Page / Hosted Tokenization Page / Server-to-server).
• Effectuer tous les appels API liés au traitement des paiements (c'est-à-dire CreateHostedCheckout, CreatePayment, RefundPayment et bien d'autres).

Pour tirer pleinement parti de ce SDK, assurez-vous de remplir ces conditions :

• .NET Framework 4.6.1 et versions ultérieures / .NET Core 2.0 et versions ultérieures
• IDE : Visual Studio 2019 ou JetBrains Rider
• Plateforme : Windows, Linux (pour .NET Core 2.0 et versions ultérieures), macOS ( .NET Core 2.0 et versions ultérieures)

Trouvez plus de détails sur ces exigences sur GitHub. Consultez également tous les objets et propriétés SDK disponibles dans notre API Reference complète.

Téléchargez la version la plus récente et suivez les instructions d'installation. Une fois que vous êtes prêt, lisez les chapitres suivants pour savoir comment préparer et utiliser le SDK.

Initialisation

Pour utiliser le SDK pour connecter votre système à notre plateforme, vous devez d'abord l'initialiser.

L'initialisation nécessite de :

• Créer un compte test/production.
• Créer une API Key et un API Secret pour le PSPID que vous souhaitez utiliser pour le traitement des transactions.
• Initialiser une instance de IClient en utilisant la clé API/le API Secret pour établir la connexion à notre plateforme de test/production.

Après l'initialisation, vous pouvez commencer à traiter les transactions via votre PSPID. Découvrez comment cela fonctionne dans le chapitre dédié.

Consultez l'exemple de code couvrant les étapes mentionnées ci-dessus :

    // Declare the IClient field for the SDK initialisation and for later use.
    private IClient client;

    // In case you use one PSPID, declare the IMerchantClient field.
    private IMerchantClient merchantClient;

    public void SetupDirectSDK()
    {
        // Create a URI to target our test or live environment
        Uri apiEndpoint = new Uri("preprod.direct.worldline-solutions.com/");

        // Initialise client with the Uri and your API key/API secret from your PSPID
        client = Factory.CreateClient(new CommunicatorConfiguration()
        {
            ApiKeyId = apiKey,
            SecretApiKey = apiSecret,
            Integrator = integrator,
            ApiEndpoint = apiEndpoint,
        });

        // In case you have multiple PSPIDs, please substitute the merchantClient in the subsequent examples with this code sample:
        merchantClient = client.WithNewMerchant(merchantId);
    }

Le tableau suivant donne un aperçu des arguments acceptés par les instances individuelles :

Après avoir initialisé le SDK, vous pouvez envoyer des requêtes à notre plateforme via votre PSPID. Apprenez comment faire cela dans le prochain chapitre.

Utiliser le SDK

Après l'initialisation réussie de l'instance IClient, vous disposez d'un accès complet à notre API RESTful. Cela vous permet de :

• Envoyer des requêtes pour de nouvelles transactions pour n'importe laquelle de nos modes d'intégration serveur.
• Obtenir le statut actuel de vos transactions.
• Effectuer des requêtes de maintenance (captures, remboursements, etc.) sur des transactions existantes.

Consultez nos cas de test sur GitHub, incluant des exemples de code complets, et notre API Reference complète pour découvrir ce qui est possible.

client.CloseIdleConnections(yourTimespan)

Ci-dessous, vous pouvez trouver certaines des actions les plus courantes que vous pouvez effectuer.

• Créer de nouvelles transactions
• Obtenir le statut de la transaction
• Effectuer une opération de maintenance

Créer de nouvelles transactions

Pour créer une nouvelle transaction, vous pouvez utiliser soit l'instance IMerchantClient, soit l'instance IClient pour l'une de nos modes d'intégration pour créer une nouvelle transaction. Cela peut être fait en :

• Routant la demande vers votre PSPID sur notre plateforme (pour IClient).
• Créant une demande pour la méthode d'intégration respective.

Vous trouverez ci-dessous des exemples de code liés à des modes d'intégration particulières :

• Hosted Checkout Page
• Hosted Tokenization Page
• Server-to-server

Hosted Checkout Page

Pour utiliser cette méthode d'intégration, vous devez créer un appel CreateHostedCheckoutRequest. Il doit contenir au minimum un objet Order.

        /*
         *…. Initialisation....
         */
        
        CreateHostedCheckoutRequest createHostedCheckoutRequest = new CreateHostedCheckoutRequest
        {
            Order = new Order
            {
                AmountOfMoney = new AmountOfMoney
                {
                    Amount = 100,
                    CurrencyCode = "EUR"
                }
            }
        };

        // Use the IMerchantClient for an asynchronous request routed to your PSPID
        var createHostedCheckoutResponse = await merchantClient
            .HostedCheckout
            .CreateHostedCheckout(createHostedCheckoutRequest);

Cet appel renvoie une réponse CreateHostedCheckoutResponse. Stockez le HostedCheckoutId et le RETURNMAC qu'il contient, ainsi que toute autre information pertinente pour vous. Vous en aurez besoin pour les étapes décrites dans les chapitres suivants.

Cette réponse contient également une PartialRedirectURL.

Vous devez concaténer l'URL de base "https://payment." avec PartialRedirectURL selon la formule

https://payment. + PartialRedirectURL

et effectuer une redirection de votre client vers cette URL. Une fois que le client visite le Hosted Checkout Page, le processus de paiement se poursuit là-bas.

Hosted Tokenization Page

Pour utiliser cette méthode d'intégration, vous devez :

• Créer et télécharger un modèle comme décrit dans notre guide Hosted Tokenization Page.

private CreateHostedTokenizationRequest createHostedTokenizationRequest = new CreateHostedTokenizationRequest();
CreateHostedTokenizationRequest createHostedTokenizationRequest = new CreateHostedTokenizationRequest();

        // Initiate fields for a minimal CreateHostedTokenizationRequest
        createHostedTokenizationRequest.Variant = "my-custom-template.html";


        // Use the IMerchantClient for an asynchronous request routed to your PSPID
        var createHostedTokenizationResponse = await merchantClient
            .HostedTokenization
            .CreateHostedTokenization(createHostedTokenizationRequest);

À partir de CreateHostedTokenizationResponse, récupérez HostedTokenizationId et PartialRedirectUrl. Utilisez PartialRedirectUrl pour l'iframe et HostedTokenizationId ou TokenId (voir encadré) pour créer le paiement réel via la méthode d'intégration Server-to-server.

// Get the result of the tokenization session
var getHostedTokenizationResponse = await client
	.WithNewMerchant("YourPSPID")
	.HostedTokenization
	.GetHostedTokenization(createHostedTokenizationResponse.HostedTokenizationId);

// Get the tokenId to be used for payment creation
var tokenId = getHostedTokenizationResponse.Token.Id;
CreatePaymentRequest requestBody = new CreatePaymentRequest
{
	CardPaymentMethodSpecificInput = new CardPaymentMethodSpecificInput
	{
		Token = tokenId // Token received by calling GetHostedTokenization()
	},
	Order = new Order
	{
		AmountOfMoney = new AmountOfMoney
		{
			Amount = 100, // The amount you want to charge your customer multiplied by 100 (1.00 EUR)
			CurrencyCode = "EUR"
		}
	}
};

var response = await client
	.WithNewMerchant("YourPSPID")
	.Payments
	.CreatePayment(requestBody);

Server-to-server

Une CreatePaymentRequest minimale nécessite de définir au moins un objet Order et un moyen de paiement :

// Initiate fields for a minimal CreatePaymentResponse
CreatePaymentRequest body = new CreatePaymentRequest
{
    Order = new Order
    {
        AmountOfMoney = new AmountOfMoney
            {
                Amount = 100,
                CurrencyCode = "EUR"
            }
    },
    CardPaymentMethodSpecificInput = new CardPaymentMethodSpecificInput // Find more test data here 
    {
        Card = new Card
        {
            CardholderName = "Wile E. Coyote",
            CardNumber = "4111111111111111",
            Cvv = "123",
            ExpiryDate = "1236"
        }
    }
};



// Use the IMerchantClient for an asynchronous request routed to your PSPID
var createPaymentResponse = await merchantClient
    .Payments
    .CreatePayment(body);

Obtenir le statut de la transaction

Notre API RESTful vous permet de demander le statut d'une transaction à tout moment via l'un de nos appels GET :

• GetHostedCheckout
• GetPaymentDetails
• GetCaptures
• GetRefunds

Une requête GetPaymentDetails ressemble à ceci :

// Use the IMerchantClient for an asynchronous request routed to your PSPID
PaymentResponse paymentResponse = await merchantClient
.Payments
.GetPaymentDetails(paymentId);

Pour plus d'informations sur les statuts, visitez la page de documentation des statuts.

Effectuer une opération de maintenance

Pour effectuer des actions de suivi sur des transactions existantes (c'est-à-dire des captures ou des remboursements), utilisez respectivement notre appel API CapturePayment ou RefundPayment :

CapturePayment

CapturePaymentRequest body = new CapturePaymentRequest
{
    Amount = 100,
    IsFinal = true
};

// Use the IMerchantClient for an asynchronous request routed to your PSPID
CaptureResponse captureResponse = await merchantClient
    .Payments
    .CapturePayment(paymentId, body);

RefundPayment

RefundRequest body = new RefundRequest

Amount = new AmountOfMoney
{
       	Amount = 100,
CurrencyCode = "EUR"
    
};

// Use the IMerchantClient for an asynchronous request routed to your PSPID
RefundResponse refundRespsonse = await merchantClient
    .Payments
    .RefundPayment(paymentId, body);

Gérer les exceptions

Si une transaction est rejetée, notre plateforme fournit des informations détaillées avec une instance Exception. Le code de statut HTTP associé vous aide également à résoudre l'erreur.

Vous pouvez rencontrer deux types d'exceptions : exceptions de transaction et exceptions HTTP.

Exceptions de transaction

Ce type d'exception se réfère aux requêtes de transaction qui sont techniquement correctes mais qui ont été rejetées par l'émetteur de votre client ou votre acquéreur. Si la transaction est retournée dans l'exception, alors elle a été créée dans nos systèmes mais n'a pas été traitée avec succès.

CreatePaymentRequest body = CreateRequest();
string paymentId;

try
{
     CreatePaymentResponse response = await merchantClient
        .Payments
        .CreatePayment(body);
     paymentId = response.Payment.Id;
}

catch (DeclinedPaymentException e)

{
    PaymentResponse payment = e.CreatePaymentResponse.Payment;
    paymentId = payment.Id;
    System.Console.WriteLine(e.Message);
    foreach (APIError error in e.Errors)
    {

        System.Console.WriteLine("Error {0}: {1}, {2}", error.Code, error.Id, error.Message);
    }
}    
PaymentResponse paymentResponse = await merchantClient
        .Payments
        .GetPayment(paymentId);

if (IsNotSuccessful(paymentResponse))
{
    HandleError(paymentResponse);
}

RefundRequest body = createRequest();

String refundId; 
try

{
    RefundResponse response = await merchantClient
        .Payments
        .RefundPayment(paymentId, body);     
    refundId = response.Id;
}

catch (DeclinedRefundException e)
{
    RefundResponse refund = e.RefundResponse;
    refundId = refund.Id;
    System.Console.WriteLine(e.Message);
    foreach (APIError error in e.Errors)
    {
        System.Console.WriteLine("Error {0}: {1}, {2}", error.Code, error.Id, error.Message);
    }
}

RefundsResponse refunds = await merchantClient
        .Refunds
        .GetRefunds(paymentId);

if (IsNotSuccessful(refunds, refundId))
{
    HandleError(refunds);
}

Exceptions HTTP

Ce type d'exception se réfère à divers problèmes causés par des erreurs techniques lors de l'appel API ou de la demande de paiement.

Vous pouvez combiner n'importe lequel des extraits de code suivants avec cette demande standard CreatePayment :

CreatePaymentResponse createPaymentResponse;

// Initier les champs pour un CreatePaymentResponse minimal
CreatePaymentRequest body = new CreatePaymentRequest()
{
    Order = new Order
    {
        AmountOfMoney = new AmountOfMoney
            {
                Amount = 100,
                CurrencyCode = "EUR"
            }
    },
    CardPaymentMethodSpecificInput = new CardPaymentMethodSpecificInput
    {
        Card = new Card
        {
            CardholderName = "Wile E. Coyote",
            CardNumber = "4111111111111111",
            Cvv = "123",
            ExpiryDate = "1236"
        }
    }
};

// Utilisez l'IMerchantClient pour une requête asynchrone adressée à votre PSPID 
try
{
createPaymentResponse = await merchantClient
    .Payments
    .CreatePayment(body);
}
catch (ApiException e)
{
    // reportez-vous à la liste ci-dessous pour voir comment gérer des implémentations spécifiques de ApiException.
}

catch (ValidationException e)
{
    System.Console.WriteLine("Erreur de validation des entrées :");
    foreach (APIError error in e.Errors)
    {
        if (error.PropertyName == null)
        {
             System.Console.WriteLine("- {0}: {1}", error.Code, error.Message);
        }

        else
        {
            System.Console.WriteLine("- {0}: {1}: {2}", error.PropertyName, error.Code,      
          error.Message);
        }
    }
}

catch (AuthorizationException e)

{
    System.Console.WriteLine("Erreur d'autorisation :");
    foreach (APIError error ine.Errors)
    {
         System.Console.WriteLine("- {0}: {1}", error.Code, error.Message);
    }
}

catch (IdempotenceException e)
{
    System.Console.WriteLine("Erreur d'autorisation :");
    foreach (APIError error in e.Errors)
    {
        System.Console.WriteLine("- {0}: {1}", error.Code, error.Message);
    }
}

catch (ReferenceException e)
{
    System.Console.WriteLine("Référence d'objet incorrecte :");
    foreach (APIError error in e.Errors)
    {
        System.Console.WriteLine("- {0}: {1}", error.ErrorCode, error.Message);
    }
}

catch (PlatformException e)
{
    System.Console.WriteLine("Une erreur est survenue sur la plateforme de paiement ou chez un partenaire/acquéreur en aval :");
    foreach (APIError error in e.Errors)
    {
        System.Console.WriteLine("- {0}: {1}", error.ErrorCode, error.Message);
    }
}

catch (ApiException e)
{
    System.Console.WriteLine("Erreur de plateforme : ");
    foreach (APIError error in e.Errors)
    {
        System.Console.WriteLine("- {0}: {1}", error.ErrorCode, error.Message);
    }
}

catch (CommunicationException e)
{
    System.Console.WriteLine("Erreur de communication : {0}", e.InnerException.ToString());
}

Codes de statut HTTP

Toutes nos exceptions sont liées à un ou plusieurs codes de statut HTTP, indiquant la cause première de nombreuses erreurs possibles.

DeclinedPaymentException

DeclinedPayoutException

DeclinedRefundException

ValidationException

AuthorizationException

ReferenceException

IdempotenceException
ReferenceException

ReferenceException

PlatformException

PlatformException

PlatformException

ApiException

Fonctionnalités supplémentaires

Le SDK a beaucoup plus à offrir. Jetez un œil aux fonctionnalités suivantes, elles vous aideront à construire la solution parfaite.

• Obtenir les méthodes de paiement disponibles
• Envoyer des requêtes idempotentes
• Utiliser la Logging
• Pool de connexions
• Personnaliser la communication
• Webhooks

Obtenir les méthodes de paiement disponibles

Avant de lancer le processus de paiement actuel, vous envoyez une requête GetPaymentProducts à notre plateforme. La réponse contient une liste des méthodes de paiement disponibles dans votre PSPID. Selon les préférences de vos clients, vous pouvez offrir une sélection sur notre Hosted Checkout Page ou dans votre propre environnement de boutique en ligne en utilisant des requêtes CreatePayment ultérieures.

// Prepare the request to get all active payment methods in your PSPID
var queryParams = new GetPaymentProductsParams
{
    CountryCode = "BE",
    CurrencyCode = "EUR"
};

// Send the request and get the response
GetPaymentProductsResponse response = await client
    .WithNewMerchant("YourPSPID")
    .Products
    .GetPaymentProducts(queryParams);

Envoyer des requêtes idempotentes

L'une des principales caractéristiques de l'API REST est sa capacité à détecter et à empêcher l'envoi accidentel de requêtes (c'est-à-dire des demandes de paiement) en double. Le SDK vous facilite la tâche pour vous assurer que vous envoyez uniquement des requêtes uniques – idempotentes – à notre plateforme.

Utilisez l'argument supplémentaire CallContext avec sa propriété IdempotenceKey pour une requête CreatePayment. Le SDK enverra un en-tête X-GCS-Idempotence-Key avec la clé d'idempotence comme valeur.

Si vous envoyez des requêtes de cette manière à notre plateforme, nous vérifierons les points suivants :

• Si vous envoyez une requête ultérieure avec la même clé d'idempotence, la réponse contient un en-tête X-GCS-Idempotence-Request-Timestamp. Le SDK définira la propriété IdempotenceRequestTimestamp de l'argument CallContext.
• Si la première requête n'est pas encore terminée, l'API Serveur RESTful renvoie un code de statut 409. Le SDK lance alors une IdempotenceException avec la clé d'idempotence originale et l'horodatage de la requête d'idempotence.

CreatePaymentRequest body = createRequest();
        string idempotenceKey = "YourKeyForThePayment";
        var merchantId = "YourPSPID";
        CallContext context = new CallContext().WithIdempotenceKey(idempotenceKey);
        try
        {
            CreatePaymentResponse response = await client
                .WithNewMerchant(merchantId)
                .Payments
                .CreatePayment(body);
        }
        catch (IdempotenceException e)
        {
            // A request with the same idempotenceKey is still in progress, try again after a short pause
            // e.IdempotenceRequestTimestamp contains the value of the
            // X-GCS-Idempotence-Request-Timestamp header
        }
        finally
        {
            long? idempotenceRequestTimestamp = context.IdempotenceRequestTimestamp;
            // idempotenceRequestTimestamp contains the value of the
            // X-GCS-Idempotence-Request-Timestamp header
            // if idempotenceRequestTimestamp is not null this was not the first request
        }

Utiliser la logging

Le SDK prend en charge la logging des requêtes, des réponses et des exceptions. Cela peut être utile pour résoudre les problèmes ou tracer les étapes individuelles dans le flux de paiement.
Le SDK propose deux implémentations de la fonctionnalité de logging :

• System.Console (SystemConsoleCommunicatorLogger)
• NLog (NLogCommunicatorLogger)

Vous pouvez activer/désactiver la logging en appelant respectivement les méthodes EnableLogging/DisableLogging sur une instance d'IClient :

client = Factory.CreateClient(new CommunicatorConfiguration()
{
    ApiKeyId = apiKey,
    SecretApiKey = apiSecret,
    Integrator = integrator,
    ApiEndpoint = apiEndpoint,
});
ICommunicatorLogger logger = new NLogCommunicatorLogger(Logger.GetCurrentClassLogger(), Level.Info);
client.EnableLogging(logger);
//... Do some calls
client.DisableLogging();

Pool de connexions

Vous pouvez gérer vos ressources réseau en limitant le nombre de connexions possibles que le SDK crée et maintient. Les instances IClient créées comme discuté dans le chapitre Initialiser le SDK auront leur propre pool de connexions. Les instances IClient créées avec le même objet ICommunicator partagent un pool de connexions.

Si vous utilisez plusieurs instances IClient pour partager un seul pool de connexions, assurez-vous de suivre ces étapes :

1. Créez un ICommunicator partagé. Vous pouvez utiliser la classe Factory pour cela.
2. Créez des instances IClient avec ce ICommunicator.

 ICommunicator communicator = Factory.CreateCommunicator(new CommunicatorConfiguration()
 {
     ApiKeyId = apiKey,
     SecretApiKey = apiSecret,
     Integrator = integrator,
     ApiEndpoint = apiEndpoint,
 });

// create one or more clients using the shared communicator
IClient client = Factory.CreateClient(communicator);

Si vous n'avez plus besoin du ICommunicator, nous vous recommandons de le fermer. Gardez à l'esprit les points suivants :

• Comme ICommunicator et IClient implémentent System.IDisposable, vous pouvez les utiliser dans les instructions using.
• Utilisez la méthode CloseExpiredConnections soit sur l'instance ICommunicator, soit sur les instances IClient pour éliminer les connexions HTTP expirées.

Personnaliser la communication

Les instances IClient utilisent une instance ICommunicator pour communiquer avec notre plateforme. Les implémentations de ICommunicator transforment un objet de requête en une requête HTTP et une réponse HTTP en un objet de réponse.

Le SDK fournit une implémentation par défaut de ICommunicator, mais vous pouvez fournir votre propre implémentation de cette interface pour l'adapter à vos besoins individuels :

ICommunicator communicator = new YourCommunicator(); 
IClient client = Factory.CreateClient(communicator); 

Fournir votre propre implémentation n'est pas nécessaire dans la plupart des cas. La fonctionnalité du Communicator par défaut repose sur les classes Authenticater, Connection, Marshaller et MetadataProvider. L'implémentation de ces classes peut facilement être étendue ou remplacée pour répondre à vos besoins. Marshaller est utilisé pour marshaller/démarshaller les objets de requête et de réponse vers et depuis JSON, ce que vous ne devriez pas changer. Les autres modules nécessaires pour communiquer avec notre plateforme sont :

• L'URI de la API endpoint serveur RESTful.
• Une Connection pour une ou plusieurs connexions HTTP à notre serveur.
• Un Authenticator pour signer vos requêtes.
• Un MetadataProvider construisant l'en-tête avec les métadonnées de votre serveur.

Pour votre commodité, un générateur ICommunicator est fourni pour remplacer facilement un ou plusieurs de ces modules. Par exemple, pour instancier un IClient qui utilise votre propre implémentation de Connection, vous pouvez utiliser l'extrait de code suivant :

IConnection connection = new YourConnection();
ICommunicator communicator = Factory.CreateCommunicatorBuilder(dictionary, "apiKeyId", "apiKey")
    .WithConnection(connection)
    .Build();
IClient client = Factory.CreateClient(communicator); 

Webhooks

La partie du SDK qui gère les webhooks s'appelle l'assistant webhooks. Il gère de manière transparente à la fois la validation des signatures par rapport aux corps d'événements envoyés par le système de webhooks (y compris la recherche de la clé secrète pour les ID de clé - à ne pas confondre avec l'API Key et l'API Secret), et le démarchage de ces corps en objets. Cela vous permet de vous concentrer sur l'essentiel, sans avoir à parcourir toutes les informations supplémentaires et à extraire celles souhaitées par vous-même. Pour en savoir plus sur les webhooks, lisez notre guide dédié. 

Fournir des clés secrètes

Configurez les "WebhooksKey" / "WebhooksKeySecret" et les API endpoints webhooks de votre serveur dans le Merchant Portal :

String keyId = "WebhooksKey";
String secretKey = "WebhooksKeySecret";

Utilisez InMemorySecretKeyStore.Instance.StoreSecretKey(keyId, secretKey) pour stocker une clé secrète pour un ID de clé.

Vous pouvez ajouter ou supprimer des clés en utilisant les fonctions suivantes :

• InMemorySecretKeyStore.Instance.GetSecretKey(keyId)
• InMemorySecretKeyStore.Instance.RemoveSecretKey(keyId) pour supprimer la clé secrète stockée pour un ID de clé
• InMemorySecretKeyStore.Instance.Clear() pour supprimer toutes les clés secrètes stockées

Si vous avez besoin d'un stockage plus avancé, par exemple en utilisant une base de données ou un système de fichiers, nous vous recommandons de créer votre propre implémentation. 

Initialiser l'assistant webhooks

En utilisant une implémentation de com.onlinepayments.webhooks.SecretKeyStore, créez une instance de com.onlinepayments.webhooks.WebhooksHelper :

WebhooksHelper helper = new WebhooksHelper(DefaultMarshaller.Instance, InMemorySecretKeyStore.Instance);

Utiliser l'assistant webhook

Pour traiter les événements reçus dans un webhook, appelez d'abord la méthode unmarshal de l'objet WebhooksHelper. Elle prend les arguments suivants : 

• Le corps, sous forme de chaîne. Il s'agit du corps brut tel qu'il est reçu du système de webhooks

  String bodyOfRequest = "JSON_Body_Of_The_Request";

• Une liste d'en-têtes de requête tels que reçus du système de webhooks. Vous trouverez ci-dessous un exemple de création d'une liste d'en-têtes de requête. Elle doit contenir les deux en-têtes pour le keyId et la signature :
  
  

  // Retrieve the headers from the Webhook message, depends on your implementation.
  var webhookHeaders = request.Headers;
  
  // Transform the received headers
  var requestHeaders = new List<RequestHeader>();
  foreach (var webhookHeader in webhookHeaders)
  {
      requestHeaders.Add(new RequestHeader(webhookHeader.Name, webhookHeader.Value));
  }

• Vous pouvez maintenant utiliser l'assistant webhook pour démarcher les événements entrants, ce qui vous permet de traiter les données dans votre application :
  
  

  try
  {
      WebhooksEvent webhooksEvent = helper.Unmarshal(bodyOfRequest, requestHeaders);
  }
  catch (SignatureValidationException ex)
  {
      // Your code to handle errors
  }