Example Integration Flows

This section demonstrates common integration patterns using the MIDSuite Client API. These examples illustrate how multiple services can be combined to support real-world fraud prevention and identity verification workflows.

Each flow represents a typical sequence of decisions an application might perform during checkout, account activity, or user verification.

Basic Checkout Flow

A basic checkout flow validates payment details and evaluates fraud risk before completing a purchase.

This pattern is commonly used by e-commerce platforms or digital subscription services.

Flow Steps

1. Customer submits checkout form with payment details.

2. The merchant backend calls PreCheck to validate card data and verify AVS/CVV.

3. If PreCheck succeeds, the backend calls Rules to evaluate fraud risk.

4. The Rules result determines the transaction outcome.

5. The merchant proceeds with payment authorization if the transaction is accepted.

Example Flow

Customer Checkout
        │
        ▼
   PreCheck API
   (card validation)
        │
        ▼
    Rules API
 (fraud decisioning)
        │
        ▼
  ACCEPT → Continue with payment authorization
  REVIEW → Manual review or step-up verification
  DENY   → Reject transaction

Typical Decision Logic

This approach provides a fast, lightweight fraud evaluation suitable for most transactions.

High-Risk Transaction Flow

For transactions with elevated fraud risk (large purchases, high-risk geographies, or suspicious behavior), additional analysis may be required.

This pattern incorporates Sentry to analyze device behavior, session characteristics, and contextual signals.

Flow Steps

1. Customer begins checkout.

2. The client application collects device and session data.

3. Backend sends a request to Sentry.

4. Sentry returns behavioral risk scores.

5. Backend calls Rules with transaction context.

6. Final transaction decision is determined.

Example Flow

Customer Checkout
        │
        ▼
   Sentry API
(device & behavioral analysis)
        │
        ▼
    Rules API
 (risk decision engine)
        │
        ▼
Transaction Decision

Example Decision Strategy

Example merchant logic:

if sentry.requestScore > 0.8:
    deny_transaction()

elif rules.status == "REVIEW":
    require_additional_verification()

elif rules.status == "ACCEPT":
    continue_checkout()

This approach provides deeper protection against bot activity, account takeovers, and coordinated fraud attempts.

Identity Verification Before Purchase

Some industries require identity verification prior to completing a transaction. Examples include financial services, age-restricted products, and high-value purchases.

The ID Verify service allows verification of identity attributes such as name, phone number, email, and government-issued identification numbers.

Flow Steps

1. Customer submits identity information during signup or checkout.

2. Backend calls ID Verify.

3. Verification results are evaluated.

4. If identity is confirmed, checkout proceeds.

Example Flow

Customer Registration / Checkout
        │
        ▼
   ID Verify API
(identity verification)
        │
        ▼
Verification Results
        │
        ▼
MATCH      → Continue transaction
NO_MATCH   → Request additional identity proof
UNKNOWN    → Manual review

Example Use Cases

Common scenarios include:

• Verifying identity before issuing digital goods

• Compliance checks for regulated industries

• Preventing account creation with stolen credentials

• Identity confirmation for large financial transactions

Pipeline-First Integration Pattern

For many integrations, the recommended approach is to use the Pipeline API.

A pipeline executes multiple services within a single request and returns the combined results. This simplifies integration logic and reduces the number of network calls.

Advantages of Pipelines

• Single API request

• Centralized orchestration

• Reduced latency

• Consistent decision output

• Easier operational management

Example Pipeline Flow

Client Request
     │
     ▼
Pipeline API
     │
     ├── PreCheck
     ├── Sentry
     ├── Rules
     └── ID Verify
     │
     ▼
Unified Pipeline Response
     │
     ▼
Merchant Decision Logic

Example Merchant Logic

pipelineResponse = callPipeline()

if pipelineResponse.rulesResponse.status == "DENY":
    reject_transaction()

if pipelineResponse.rulesResponse.status == "REVIEW":
    trigger_manual_review()

if pipelineResponse.rulesResponse.status == "ACCEPT":
    continue_checkout()

When to Use Pipelines

Pipelines are recommended when:

• Multiple MIDSuite services are used together

• Fraud analysis must occur in a specific sequence

• Latency and simplicity are important

• Integration logic should remain minimal on the client side

Choosing the Right Integration Pattern

Many merchants begin with individual services and later transition to pipelines as their fraud strategy evolves.