Order Verification

AI-powered fraud detection system for e-commerce orders that analyzes customer, address, device, and behavioral data to identify fraudulent transactions in real-time.

Overview

Order Verification uses advanced AI combined with web research to assess the fraud risk of e-commerce orders. The system analyzes multiple data points including customer information, shipping/billing addresses, IP geolocation, device fingerprints, and behavioral patterns to generate a comprehensive risk assessment.

Key Features

AI-Powered Analysis: Intelligent fraud detection and risk assessment
Comprehensive Verification: Checks fraud databases, blacklists, and reputation sites
IP Validation: Validates IP addresses against order addresses
Risk Scoring: Simple 0-100 risk score with clear thresholds
Detailed Risk Factors: Categorized fraud indicators with severity levels
Actionable Recommendations: Specific next steps based on risk level
Privacy-Focused: Only order ID and AI analysis stored for audit trail
API-First: Easy integration with any e-commerce platform

How It Works

1. Data Collection

The system accepts comprehensive order data including:

Order details (amount, currency, timestamp, line items)
Customer information (name, email, phone, account history)
Customer purchase history (total orders, cancellations, returns, average order value)
Company details (optional)
Shipping and billing addresses
Payment information (brand, last four digits, expiry, holder name)
Technical data (IP address, user agent)

2. Analysis Process

The system performs comprehensive fraud verification:

Validates and standardizes all input data
Checks IP address location against shipping/billing addresses
Searches for customer email/phone in fraud databases
Verifies company name and address legitimacy
Validates shipping and billing addresses for real-world existence and accuracy
Checks for disposable email services
Analyzes IP reputation and proxy/VPN detection
Evaluates behavioral patterns and order characteristics
Analyzes customer purchase history patterns (cancellation rates, return rates)
Reviews order item combinations for suspicious patterns
Compares current order value to customer's average order value

3. Results

The system returns:

Risk Score: 0-100 numerical score
Risk Level: Low, Medium, High, or Critical
Risk Factors: Detailed list of fraud indicators
Reasoning: Analysis explanation
Recommendations: Actionable next steps

Risk Scoring System

Risk Levels

Score Range	Level	Description	Action
0-30	Low Risk	Legitimate order with minimal red flags	Safe to process normally
31-60	Medium Risk	Some suspicious indicators present	Manual review recommended
61-85	High Risk	Multiple fraud indicators detected	Reject or verify customer
86-100	Critical Risk	Definitive fraud signals found	Reject immediately

Risk Factor Categories

Customer Risk

Email found in fraud databases
Disposable or suspicious email domain
Phone number invalid or VoIP
Fake-sounding name
New account with high-value order
Found in scam reports

Address Risk

Invalid or non-existent address
Billing and shipping in different countries
Address associated with freight forwarders
PO box for high-value items
Postal code mismatch
Known fraud location

Payment Risk

Mismatch between cardholder name and customer name
Prepaid or high-risk card brands
Multiple failed payment attempts
Suspicious card expiry patterns

Technical Risk

VPN, proxy, or datacenter IP
IP location doesn't match addresses
IP found in spam/fraud databases
Suspicious device fingerprint
Bot-like user agent patterns

Behavioral Risk

First-time customer with large order
Multiple orders in short timeframe
Unusual order timing
Rush delivery request
Order value inconsistent with history
High cancellation or return rate
Low fulfillment rate compared to total orders
Order significantly exceeds average order value
Suspicious product combinations in order items

Severity Levels

Each risk factor has a severity level:

Low: Minor inconsistency, not necessarily fraud
Medium: Suspicious indicator worth noting
High: Strong fraud signal
Critical: Definitive fraud indicator

Using the UI

Step 1: Access the Page

Navigate to Order Verification from the dashboard menu.

Step 2: Fill Out the Form

Complete the order information form with as much data as available:

Order Information (Required)

Order Amount and Currency
Optional: Order ID and timestamp

Customer Information (Required)

Full name and email address
Optional: Phone number
Mark if first-time customer
Account age

Company Information (Optional)

Company name and address
Useful for B2B orders

Addresses (Required)

Complete shipping address
Complete billing address
Use "Same as shipping" checkbox if identical

Payment Information (Optional but recommended)

Card brand and last four digits
Expiry date and cardholder name
Helps correlate payment data with customer identity

Technical Details (Optional but recommended)

IP address for geolocation
User agent string
Device fingerprint

Additional Notes

Any special order notes or concerns

Step 3: Submit for Verification

Click "Verify Order" to start the analysis. The system will:

Validate all input data
Check your credit balance
Run AI-powered fraud detection
Return results in 15-30 seconds

Step 4: Review Results

The results panel displays:

Risk Score Gauge

Visual indicator with color coding
Clear risk level (Low/Medium/High/Critical)
Progress bar showing score position

Risk Factors Table

Grouped by category (Customer, Address, Technical, Behavioral)
Each factor shows severity badge
Detailed description of why it's a risk

Analysis Section

AI's reasoning and thought process
Explanation of the risk score
Context about the findings

Recommendations List

Specific actions to take
Based on risk level
Actionable next steps

Best Practices

Data Collection

Collect Complete Data: More data = better accuracy
Always Include IP Address: Enables geolocation checks
Capture Device Fingerprints: Helps identify repeat fraudsters
Record User Agents: Detects bot activity
Collect Payment Details: Helps verify cardholder identity and detect high-risk cards (Optional but recommended)
Track Account History: Account age and order history matter

When to Run Verification

Pre-Authorization: Before charging the card
High-Value Orders: Always verify orders above threshold
Suspicious Patterns: Multiple orders, new account, etc.
International Orders: Higher fraud risk generally
After Hours: Orders placed at unusual times

Interpreting Results

Low Risk (0-30)

Process order normally
Standard fulfillment procedures
No additional verification needed

Medium Risk (31-60)

Manual Review: Have staff examine the order
Contact Customer: Email or call to verify
Check Payment: Ensure payment method is valid
Small Test Order: Consider fulfilling partial order first

High Risk (61-85)

Do Not Process: Hold the order
Identity Verification: Request photo ID
Video Call: Verify customer via video
Alternative Payment: Request wire transfer or alternative
Reject if Unverifiable: Better safe than sorry

Critical Risk (86-100)

Reject Immediately: Do not process
Block Customer: Prevent future orders
Report if Confirmed: Add to fraud databases
Review Similar Orders: Check for patterns

Integration Tips

Automate Low Risk: Auto-approve orders scoring under 30
Queue Medium Risk: Send to manual review queue
Auto-Reject High/Critical: Block automatically or require verification
Set Thresholds: Adjust based on your risk tolerance
Monitor Patterns: Track false positives/negatives
Update Rules: Refine based on actual fraud rates

Privacy Considerations

Only the order ID plus AI-generated score, level, analysis, factors, and recommendations are stored for audit trail purposes
Full order details remain transient; AI usage and credit transactions are logged separately
Provide clear privacy policy to customers
Comply with GDPR/CCPA requirements
Consider data retention needs for your records

Common Use Cases

Shopify

Do not write this integration. The Verify AI Shopify app does it natively: it scores each new order from the orders/create webhook, renders the assessment on the order details page, adds an action for older and draft orders, and writes the risk band back as an order tag your Shopify Flow rules can act on.

Install it from the Shopify App Store and approve the scopes. There is no API key to create and no code to deploy.

WooCommerce Integration

// In WooCommerce order creation hook
add_action('woocommerce_checkout_order_processed', function($order_id) {
    $order = wc_get_order($order_id);

    $order_data = [
        'orderId' => $order_id,
        'orderAmount' => $order->get_total(),
        'currency' => $order->get_currency(),
        'customerName' => $order->get_billing_first_name() . ' ' .
                         $order->get_billing_last_name(),
        'customerEmail' => $order->get_billing_email(),
        'customerPhone' => $order->get_billing_phone(),
        'isFirstTimeCustomer' => $order->get_customer_id() === 0,
        'shippingAddress' => [
            'street' => $order->get_shipping_address_1(),
            'city' => $order->get_shipping_city(),
            'state' => $order->get_shipping_state(),
            'postalCode' => $order->get_shipping_postcode(),
            'country' => $order->get_shipping_country()
        ],
        'billingAddress' => [
            'street' => $order->get_billing_address_1(),
            'city' => $order->get_billing_city(),
            'state' => $order->get_billing_state(),
            'postalCode' => $order->get_billing_postcode(),
            'country' => $order->get_billing_country()
        ],
        'paymentInfo' => [
            'brand' => $order->get_payment_method_title(),
            'lastFourDigits' => $order->get_meta('_billing_card_last4'),
            'expiry' => $order->get_meta('_billing_card_expiry'),
            'holderName' => $order->get_billing_first_name() . ' ' . $order->get_billing_last_name()
        ],
        'ipAddress' => $order->get_customer_ip_address()
    ];

    // Call verification API
    $response = wp_remote_post(
        'https://verify-ai.tdcapps.com/api/{org}/order-verification',
        [
            'headers' => [
                'Authorization' => 'Bearer ' . YOUR_API_KEY,
                'Content-Type' => 'application/json'
            ],
            'body' => json_encode($order_data)
        ]
    );

    $result = json_decode(wp_remote_retrieve_body($response), true);

    if ($result['data']['riskScore'] > 60) {
        $order->update_status('on-hold', 'High fraud risk detected');
    }
});

BigCommerce Integration

// In BigCommerce order-created endpoint
app.post('/orders/created', async (req, res) => {
  const order = req.body.data

  // Fetch full order details
  const orderDetails = await bigcommerce.get(`/orders/${order.id}`)

  const orderData = {
    orderId: order.id.toString(),
    orderAmount: orderDetails.total_inc_tax,
    currency: orderDetails.currency_code,
    customerName: `${orderDetails.billing_address.first_name} ${orderDetails.billing_address.last_name}`,
    customerEmail: orderDetails.billing_address.email,
    customerPhone: orderDetails.billing_address.phone,
    isFirstTimeCustomer: orderDetails.customer_id === 0,
    shippingAddress: {
      street: orderDetails.shipping_addresses[0].street_1,
      city: orderDetails.shipping_addresses[0].city,
      state: orderDetails.shipping_addresses[0].state,
      postalCode: orderDetails.shipping_addresses[0].zip,
      country: orderDetails.shipping_addresses[0].country
    },
    billingAddress: {
      street: orderDetails.billing_address.street_1,
      city: orderDetails.billing_address.city,
      state: orderDetails.billing_address.state,
      postalCode: orderDetails.billing_address.zip,
      country: orderDetails.billing_address.country
    },
    paymentInfo: {
      brand: orderDetails.card_type,
      lastFourDigits: orderDetails.credit_card_number_last_4,
      expiry: `${orderDetails.credit_card_expiration_month}/${orderDetails.credit_card_expiration_year}`,
      holderName: `${orderDetails.billing_address.first_name} ${orderDetails.billing_address.last_name}`
    },
    ipAddress: orderDetails.ip_address
  }

  const verification = await verifyOrder(orderData)

  if (
    verification.riskLevel === 'high' ||
    verification.riskLevel === 'critical'
  ) {
    await bigcommerce.put(`/orders/${order.id}`, {
      status_id: 7 // Awaiting Review
    })
  }

  res.sendStatus(200)
})

Troubleshooting

Low Accuracy

Problem: Results don't match actual fraud patterns

Solutions:

Provide more complete data (especially IP, phone, device)
Include customer history (account age, order statistics)
Check if addresses are properly formatted
Verify IP addresses are real customer IPs (not your server)

False Positives

Problem: Legitimate orders flagged as fraud

Possible Causes:

VPN users (common for privacy-conscious customers)
International orders (different IP and shipping country)
Freight forwarders (legitimate package forwarding services)
New customers making large purchases

Solutions:

Adjust risk thresholds for your business
Manually review medium-risk orders
Whitelist known good customers
Consider context (luxury goods vs. commodity items)

API Errors

Problem: Verification fails or returns errors

Check:

API key is valid and has correct permissions
Organization slug is correct in URL
Credit balance is sufficient
Request body matches schema exactly
All required fields are provided
IP address format is valid (if provided)

Limitations

What It Can Detect

✅ Email/phone in fraud databases
✅ Disposable email addresses
✅ VPN/proxy/datacenter IPs
✅ Real-world address verification ✅ Address inconsistencies
✅ Suspicious patterns
✅ Known fraud locations

What It Cannot Detect

❌ Stolen credit cards (requires payment processor)
❌ Account takeovers (requires session analysis)
❌ Friendly fraud/chargebacks
❌ Real-time card validation
❌ Future fraudulent behavior

Best Used With

Payment processor fraud detection (Stripe Radar, etc.)
3D Secure authentication
Address verification service (AVS)
Card verification value (CVV) checks
Your own business logic and rules

Credits and Billing

Order verification consumes credits based on usage. The cost varies depending on the complexity of the verification and amount of data analyzed.

See Credits & Billing for more information about purchasing and managing credits.

Next Steps

Shopify app - Score orders without writing an integration
Order Verification API - Complete API documentation
Credits - Purchase and manage credits
Dashboard - Monitor verification usage
API Keys - Create API keys for integration