npm i @datadome/fraud-sdk-node

dotnet add package DataDome.AspNetCore.Fraud.SDK

<!-- insert in the pom.xml file of the project -->
<dependency>
  <groupId>co.datadome.fraud</groupId>
  <artifactId>fraud-sdk-java</artifactId>
  <!-- <version>1.0.1</version> --> <!-- compatible with Spring Boot 2.x -->
  <version>2.2.2</version>          <!-- compatible with Spring Boot 3.x -->
</dependency>

libraryDependencies += "co.datadome.fraud" % "fraud-sdk-java" % "2.2.1"

pip install datadome-fraud-sdk-python

composer require datadome/fraud-sdk-symfony

# 1. add `datadome/fraud-sdk-laravel` to your project
composer require datadome/fraud-sdk-laravel
# 2. Generate an autoloader
composer dump-autoload
# 3. Edit `config/app.php` to add `DataDomeServiceProvider`
# config/app.php
use DataDome\FraudSdkLaravel\Providers\DataDomeServiceProvider;
[...]
 'providers' => ServiceProvider::defaultProviders()->merge([
 [...]
 DataDomeServiceProvider::class
 
# 4. publish `datadome.php` in the `config` folder
php artisan vendor:publish

gem install datadome_fraud_sdk_ruby

go get github.com/datadome/fraud-sdk-go-package

package main

import (
  "log"
  "net/http"
  "time"

  dd "github.com/datadome/fraud-sdk-go"
)

func accountHandler(client *dd.Client) http.HandlerFunc {
  return func(w http.ResponseWriter, r *http.Request) {
    if r.Method == http.MethodPut {
      // Address field
      name := "Élysée Palace"
      line1 := "55 Rue du Faubourg Saint-Honoré"
      line2 := "2nd floor"
      city := "Paris"
      countryCode := "FR"
      regionCode := "75"
      zipCode := "75008"
      userAddress := dd.Address{
        City:        &city,
        CountryCode: &countryCode,
        Line1:       &line1,
        Line2:       &line2,
        Name:        &name,
        RegionCode:  &regionCode,
        ZipCode:     &zipCode,
      }

      // Authentication field
      authenticationMode := dd.Password
      authenticationSocialProvider := dd.Google
      authenticationType := dd.Social
      authentication := dd.Authentication{
        Mode:           &authenticationMode,
        SocialProvider: &authenticationSocialProvider,
        Type:           &authenticationType,
      }

      // User field
      createdAt := time.Now().Format(time.RFC3339)
      firstName := "Data"
      lastName := "Dome"
      title := "mr"
      phone := "+33978787878"
      email := "[email protected]"
      paymentMeanUpdated := true
      displayName := "DataDome 🤖"
      description := "Some Description / Некоторое описание"
      user := dd.User{
        ID:                 "fake_user_id",
        Address:            &userAddress,
        CreatedAt:          &createdAt,
        Email:              &email,
        FirstName:          &firstName,
        LastName:           &lastName,
        Phone:              &phone,
        Title:              &title,
        PaymentMeanUpdated: &paymentMeanUpdated,
        Authentication:     &authentication,
        DisplayName:        &displayName,
        Description:        &description,
        ExternalURLs: &[]string{
          "https://example.org/external1",
          "https://example.org/external2",
          "https://example.org/external3",
        },
        PictureURLs: &[]string{
          "https://example.org/image1.png",
          "https://example.org/image2.png",
          "https://example.org/image3.png",
        },
      }

      // Session field
      sessionId := "fake_session_id"
      session := dd.Session{
        ID:        &sessionId,
        CreatedAt: &createdAt,
      }

      validate, err := client.Validate(r, dd.NewAccountUpdateEvent(
        email,
        dd.AccountUpdateWithUser(user),
        dd.AccountUpdateWithSession(session),
      ))
      if err != nil {
        log.Printf("error during validation: %v\n", err)
      }
      if validate.Action == dd.Allow {
        w.WriteHeader(http.StatusOK)
        return
      } else {
        // Business Logic here
        // MFA
        // Challenge
        // Notification email
        // temporarly lock account
        http.Error(w, "failed", http.StatusForbidden)
        return
      }
    } else {
      http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
    }
  }
}

func main() {
  client, _ := dd.NewClient("FRAUD_API_KEY")

  mux := http.NewServeMux()
  mux.HandleFunc("/account", accountHandler(client))

  _ = http.ListenAndServe(":8080", mux)
}

client, err := dd.NewClient(
  "FRAUD_API_KEY",
  dd.ClientWithEndpoint("account-api.datadome.co"),
  dd.ClientWithTimeout(1500),
)