Go SDK

go get github.com/rdcpass/rdcpass-go

package main

import (
	"log"
	"os"

	rdcpass "github.com/rdcpass/rdcpass-go"
)

func newClient() *rdcpass.Client {
	// Staging environment: https://gateway.staging.rdcpass.cd
	client, err := rdcpass.NewClient(rdcpass.Config{
		Environment:   rdcpass.Sandbox,
		KeyID:         "key_test_3c7e1a9f42",
		KeySecret:     os.Getenv("RDCPASS_KEY_SECRET"),
		EncryptionKey: os.Getenv("RDCPASS_ENCRYPTION_KEY"),
	})
	if err != nil {
		log.Fatal(err)
	}
	return client
}

// Fields left empty are read from RDCPASS_KEY_ID, RDCPASS_KEY_SECRET,
// RDCPASS_ENCRYPTION_KEY and RDCPASS_ENVIRONMENT.
// Production (https://api.rdcpass.cd) also requires your mTLS client certificate.
client, err := rdcpass.NewClient(rdcpass.Config{
	ClientCertFile: "/etc/rdcpass/client.crt",
	ClientKeyFile:  "/etc/rdcpass/client.key",
})
if err != nil {
	log.Fatal(err)
}

package main

import (
	"context"
	"fmt"
	"log"

	rdcpass "github.com/rdcpass/rdcpass-go"
)

func main() {
	ctx := context.Background()

	client, err := rdcpass.NewClient(rdcpass.Config{})
	if err != nil {
		log.Fatal(err)
	}

	validation, err := client.KYC.Validations.Create(ctx, &rdcpass.KYCValidationParams{
		Reference:  "cust-0001",
		Identifier: rdcpass.Identifier{Type: rdcpass.IdentifierRDCPASSID, Value: "COD-2103-0214-4937"},
		Match:      &rdcpass.Match{FullName: "Kabeya Mwamba Tshisekedi", DateOfBirth: "1988-04-12"},
		Purpose:    "customer_onboarding",
		Scopes:     []string{"kyc.documents.primary", "kyc.phone_numbers"},
	})
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(validation.Result)             // verified
	fmt.Println(validation.KYC.Basic.FullName) // Kabeya Mwamba Tshisekedi
	fmt.Println(validation.ScopesWithheld)     // []
}

{
  "id": "kyc_8d2f6a1c93",
  "object": "kyc_validation",
  "livemode": true,
  "reference": "cust-0001",
  "status": "completed",
  "result": "verified",
  "certified_account": true,
  "identifier": {
    "type": "rdcpass_id",
    "value": "COD-2103-0214-4937"
  },
  "match": {
    "full_name": "match",
    "date_of_birth": "match",
    "age": "not_provided",
    "score": 0.98
  },
  "account": {
    "rdcpass_id": "COD-2103-0214-4937",
    "status": "active",
    "certified": true,
    "created_at": "2025-03-14T09:22:41Z",
    "level_of_assurance": "LOA3"
  },
  "kyc": {
    "basic": {
      "full_name": "Kabeya Mwamba Tshisekedi",
      "first_name": "Kabeya",
      "last_name": "Tshisekedi",
      "date_of_birth": "1988-04-12",
      "age": 38,
      "gender": "male",
      "nationality": "COD"
    },
    "documents": {
      "primary": {
        "type": "passport",
        "number": "OB1234567",
        "issued_at": "2022-06-01",
        "expires_at": "2027-05-31",
        "issuing_authority": "Direction Générale de Migration",
        "status": "valid",
        "image": {
          "content_type": "image/jpeg",
          "url": "https://files.rdcpass.cd/d/9f2c41e8b7a3?sig=Qm9fX2t5Y19zaWc&exp=1790418002",
          "expires_at": "2026-09-26T10:20:02Z"
        }
      }
    },
    "phone_numbers": [
      {
        "number": "+243812345678",
        "operator": "Vodacom",
        "is_primary": true,
        "verified": true
      },
      {
        "number": "+243991234567",
        "operator": "Airtel",
        "is_primary": false,
        "verified": true
      }
    ]
  },
  "scopes_applied": [
    "kyc.basic",
    "kyc.documents.primary",
    "kyc.phone_numbers"
  ],
  "scopes_withheld": [],
  "purpose": "customer_onboarding",
  "created_at": "2026-09-26T10:15:02Z"
}

// 1. Build the authorize URL. The SDK generates state and the PKCE
//    code_verifier / code_challenge (S256) for you.
auth, err := client.Login.AuthorizationURL(&rdcpass.AuthorizationURLParams{
	ClientID:    "app_8f2a1c0e9b",
	RedirectURI: "https://yourapp.example.com/callback",
	Scopes:      []string{"openid", "profile", "rdcpass:kyc.phone_numbers"},
})
if err != nil {
	return err
}
// Store auth.State and auth.CodeVerifier in the user's session,
// then redirect to auth.URL.

// 2. On your callback, check state and exchange the code.
if r.URL.Query().Get("state") != session.State {
	return errors.New("state mismatch")
}
tokens, err := client.Login.ExchangeCode(ctx, &rdcpass.ExchangeCodeParams{
	ClientID:     "app_8f2a1c0e9b",
	Code:         r.URL.Query().Get("code"),
	CodeVerifier: session.CodeVerifier,
	RedirectURI:  "https://yourapp.example.com/callback",
})
if err != nil {
	return err
}
user, err := client.Login.UserInfo(ctx, tokens.AccessToken)

// Submit up to 10,000 items asynchronously (Prefer: respond-async).
batch, err := client.KYC.Validations.Batches.Create(ctx, &rdcpass.KYCValidationBatchParams{
	Purpose: "customer_onboarding",
	Items: []rdcpass.KYCValidationParams{
		{Reference: "cust-0001", Identifier: rdcpass.Identifier{Type: rdcpass.IdentifierRDCPASSID, Value: "COD-2103-0214-4937"}},
		{Reference: "cust-0002", Identifier: rdcpass.Identifier{Type: rdcpass.IdentifierCENI, Value: "1234567890123"}},
	},
}, rdcpass.WithAsync())
if err != nil {
	return err
}

// Poll GET /v1/batches/{id} until the batch reaches a final status.
done, err := client.Batches.Wait(ctx, batch.ID, &rdcpass.WaitParams{
	PollInterval: 5 * time.Second,
	Timeout:      30 * time.Minute,
})
if err != nil {
	return err
}
fmt.Println(done.Status, done.SucceededItems, done.FailedItems)

// Iterate every result; the iterator follows next_cursor page by page.
iter := client.Batches.Results(ctx, batch.ID, &rdcpass.ListParams{Limit: 500})
for iter.Next() {
	item := iter.Current()
	fmt.Println(item.Reference, item.Status)
}
if err := iter.Err(); err != nil {
	return err
}

func rdcpassWebhook(w http.ResponseWriter, r *http.Request) {
	// Read the raw body: the signature covers "{timestamp}.{rawBody}".
	body, err := io.ReadAll(r.Body)
	if err != nil {
		http.Error(w, "cannot read body", http.StatusBadRequest)
		return
	}

	event, err := client.Webhooks.ConstructEvent(body, r.Header)
	if err != nil {
		http.Error(w, "invalid signature", http.StatusBadRequest)
		return
	}

	switch event.Type {
	case "kyc_validation.completed":
		var job rdcpass.Job
		if err := event.Data.Unmarshal(&job); err == nil {
			log.Println(job.ID, job.Status)
		}
	case "batch.completed", "batch.completed_with_errors":
		var batch rdcpass.Batch
		if err := event.Data.Unmarshal(&batch); err == nil {
			log.Println(batch.ID, batch.FailedItems)
		}
	}
	w.WriteHeader(http.StatusOK)
}

_, err := client.KYC.Validations.Create(ctx, &rdcpass.KYCValidationParams{
	Identifier: rdcpass.Identifier{Type: rdcpass.IdentifierRDCPASSID, Value: "COD-2103-0214-4937"},
	Purpose:    "customer_onboarding",
	Scopes:     []string{"kyc.biometrics.iris"},
})

var apiErr *rdcpass.Error
if errors.As(err, &apiErr) {
	log.Println(apiErr.Status, apiErr.Code, apiErr.Message, apiErr.RequestID)
	if apiErr.Code == "scope_not_granted" {
		// 403: request the scope for your application in the console
	}
} else if err != nil {
	return err
}

client, err := rdcpass.NewClient(rdcpass.Config{
	MaxRetries: 5, // default 3; set rdcpass.NoRetries to disable
})
if err != nil {
	return err
}

// Every POST gets an Idempotency-Key automatically. Pass your own to make
// retries safe across process restarts:
_, err = client.Fraud.Reports.Create(ctx, &rdcpass.FraudReportParams{
	Type: "identity_usurpation",
	Subject: rdcpass.FraudSubject{
		Identifier: rdcpass.Identifier{Type: rdcpass.IdentifierRDCPASSID, Value: "COD-2103-0214-4937"},
	},
	Description: "Account opened with a stolen passport.",
}, rdcpass.WithIdempotencyKey("fraud-case-INC-2026-88213"), rdcpass.WithMaxRetries(1))

client, err := rdcpass.NewClient(rdcpass.Config{
	Timeout: 20 * time.Second, // per attempt (default 30s)
	Logger:  slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelDebug})),
})
if err != nil {
	return err
}

// Deadlines and cancellation also follow the context you pass.
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
defer cancel()
_, err = client.AML.Screenings.Create(ctx, &rdcpass.AMLScreeningParams{
	Subject: rdcpass.AMLSubject{
		Identifier: rdcpass.Identifier{Type: rdcpass.IdentifierRDCPASSID, Value: "COD-1907-5521-0386"},
	},
	Purpose: "regulatory_compliance",
})