DEV Community: Adda

OFAC Sanctions Screening in Node.js — A Practical Guide for Fintech Developers

Adda — Thu, 21 May 2026 02:44:49 +0000

If you're building a fintech app, a payment platform, or any service that moves money, you're legally required to screen your users against the OFAC SDN (Specially Designated Nationals) list.

Fail to do it, and you're looking at fines that start at $50,000 per violation.

But implementing it yourself is surprisingly tricky. The OFAC list has 18,000+ entries. Names are in multiple languages, transliterations vary wildly, and the same person might appear under a dozen aliases. A simple string match will miss half the results.

In this guide, I'll show you how to implement proper OFAC screening with fuzzy matching in under 15 minutes.

What Is OFAC Screening?

The Office of Foreign Assets Control (OFAC) is a US Treasury department that publishes a list of individuals, companies, and countries subject to economic sanctions.

You need to screen against this list if you:

Process payments (Stripe, PayPal, crypto)
Onboard new users (KYC/AML compliance)
Work with businesses in regulated industries (banking, lending, insurance)
Handle cross-border transactions

Why Simple String Matching Fails

The SDN list entry for a sanctioned person might look like this:

PUTIN, Vladimir Vladimirovich
a.k.a. "ПУТИН, Владимир Владимирович"
a.k.a. "POUTINE, Vladimir"

If your user signs up as "Vladimir Poutine" or "V. Putin" — a === check returns false. You've missed a match.

Proper OFAC screening requires:

Fuzzy matching — handle typos, transliterations, name variations
Alias checking — check all known aliases for each entry
Configurable threshold — tune sensitivity vs false positives
Risk scoring — return confidence percentage, not just true/false

Implementation

Option 1: Build It Yourself

You could download the SDN CSV from treasury.gov, parse it, implement Levenshtein distance or Jaro-Winkler scoring, cache it in memory, and rebuild the index daily.

This takes 2-3 days to build correctly and needs ongoing maintenance as the list updates weekly.

Option 2: Use an API

const response = await fetch('https://api.stackapi.dev/api/v1/screening/screen', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: 'Vladimir Putin',
    type: 'individual',      // or 'company'
    matchThreshold: 80       // 50-100, higher = stricter
  })
});

const result = await response.json();

Response:

{
  "success": true,
  "data": {
    "entity": "Vladimir Putin",
    "isMatch": true,
    "riskLevel": "CRITICAL",
    "confidence": 97,
    "matches": [
      {
        "matchedName": "PUTIN VLADIMIR VLADIMIROVICH",
        "confidence": 97,
        "listName": "OFAC SDN",
        "program": "UKRAINE-EO13662",
        "aliases": ["ПУТИН ВЛАДИМИР ВЛАДИМИРОВИЧ"]
      }
    ],
    "screenedAt": "2025-01-15T10:30:00.000Z",
    "listsChecked": ["OFAC SDN"]
  }
}

Integrating Into Your User Onboarding Flow

Here's a complete KYC middleware for Express:

const { screening } = require('./api-client');

async function kycMiddleware(req, res, next) {
  const { fullName, companyName, entityType } = req.body;

  const nameToCheck = entityType === 'company' ? companyName : fullName;

  try {
    const result = await fetch('https://api.stackapi.dev/api/v1/screening/screen', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.FINGUARD_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        name: nameToCheck,
        type: entityType,
        matchThreshold: 85  // strict for onboarding
      })
    }).then(r => r.json());

    if (result.data.riskLevel === 'CRITICAL' || result.data.riskLevel === 'HIGH') {
      // Log for compliance audit trail
      await auditLog.record({
        action: 'KYC_BLOCKED',
        name: nameToCheck,
        riskLevel: result.data.riskLevel,
        confidence: result.data.confidence,
        matches: result.data.matches
      });

      return res.status(403).json({
        error: 'Account creation blocked pending compliance review',
        referenceId: auditLog.lastId
      });
    }

    // Attach screening result to request for downstream use
    req.kycResult = result.data;
    next();

  } catch (err) {
    // Fail closed — never allow if screening fails
    console.error('Screening service error:', err);
    return res.status(503).json({ error: 'Service temporarily unavailable' });
  }
}

// Apply to your registration route
app.post('/api/register', kycMiddleware, registerHandler);

Important: Always fail closed. If the screening service is unavailable, block the operation — never default to allowing it.

Batch Screening for Existing User Bases

Need to screen your entire existing user base? Use the batch endpoint:

async function screenAllUsers(users) {
  const BATCH_SIZE = 100;
  const results = [];

  for (let i = 0; i < users.length; i += BATCH_SIZE) {
    const batch = users.slice(i, i + BATCH_SIZE);

    const response = await fetch('https://api.stackapi.dev/api/v1/screening/batch-screen', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.FINGUARD_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        entities: batch.map(user => ({
          name: user.fullName,
          type: 'individual',
          matchThreshold: 80
        }))
      })
    }).then(r => r.json());

    results.push(...response.data.results);

    console.log(`Screened ${Math.min(i + BATCH_SIZE, users.length)} / ${users.length}`);

    // Respect rate limits
    await new Promise(r => setTimeout(r, 1000));
  }

  return results.filter(r => r.isMatch);
}

// Usage
const flaggedUsers = await screenAllUsers(allUsers);
console.log(`${flaggedUsers.length} users flagged for review`);

Understanding Risk Levels

Risk Level	Confidence	Recommended Action
`LOW`	No match found	Allow
`MEDIUM`	70-84% match	Manual review
`HIGH`	85-94% match	Escalate to compliance
`CRITICAL`	95-100% match	Block immediately

For most production use cases, HIGH and CRITICAL should block immediately. MEDIUM can go to a manual review queue.

Tuning the Match Threshold

The matchThreshold parameter controls sensitivity:

// Strict — fewer false positives, may miss some matches
{ matchThreshold: 90 }

// Recommended for production KYC
{ matchThreshold: 80 }

// Broad — catches more variations, more false positives
{ matchThreshold: 70 }

For names from regions with many transliteration variants (Arabic, Cyrillic, Chinese), 75-80 is a good starting point.

Adding PEP Screening

OFAC is just one list. Many compliance frameworks also require screening against PEP (Politically Exposed Persons) databases:

// Screen against OFAC SDN
const ofacResult = await screenEntity(name, 'individual');

// Screen against PEP list (heads of state, senior officials, etc.)
const pepResult = await fetch('https://api.stackapi.dev/api/v1/compliance/pep', {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${process.env.FINGUARD_API_KEY}`, 'Content-Type': 'application/json' },
  body: JSON.stringify({ name, matchThreshold: 75 })
}).then(r => r.json());

const overallRisk = [ofacResult.data.riskLevel, pepResult.data.riskLevel]
  .sort((a, b) => riskWeight(b) - riskWeight(a))[0];

Getting Started (Free Tier)

Subscribe at RapidAPI — FinGuard API
The free tier includes 200 screening lookups/month
Batch screening requires the ULTRA plan

Compliance Disclaimer

This article is for educational purposes. OFAC screening requirements vary by jurisdiction and business type. Consult a compliance professional for your specific situation.

Building something with OFAC screening? Drop a comment — I'd love to hear your use case.

Stop Manually Entering Invoices — AI Extraction in 5 Lines of Code

Adda — Thu, 21 May 2026 02:43:04 +0000

Accounts payable teams spend an average of 4.5 hours per week manually entering invoice data. That's 18 hours a month copying numbers from PDFs into accounting software.

With AI document extraction, you can reduce that to near zero — and it works even on scanned, hand-written, or poorly formatted invoices.

Here's how to build it in minutes.

What We're Building

A function that takes any invoice PDF (or image) and returns:

{
  "invoiceNumber": "INV-2024-001",
  "invoiceDate": "2024-03-15",
  "dueDate": "2024-04-15",
  "vendor": {
    "name": "Acme Services Inc.",
    "address": "123 Main St, Toronto, ON",
    "taxNumber": "GST 123456789 RT0001"
  },
  "lineItems": [
    { "description": "Web development", "quantity": 40, "unitPrice": 150.00, "amount": 6000.00 }
  ],
  "taxLines": [
    { "name": "GST", "rate": 5, "amount": 300.00 },
    { "name": "QST", "rate": 9.975, "amount": 598.50 }
  ],
  "total": 6898.50,
  "currency": "CAD"
}

The Code

Node.js / JavaScript

const fs = require('fs');

async function extractInvoice(filePath) {
  // Convert file to base64
  const fileBuffer = fs.readFileSync(filePath);
  const base64 = fileBuffer.toString('base64');

  // Detect MIME type from extension
  const ext = filePath.split('.').pop().toLowerCase();
  const mimeTypes = { pdf: 'application/pdf', jpg: 'image/jpeg', jpeg: 'image/jpeg', png: 'image/png' };
  const mimeType = mimeTypes[ext] || 'application/pdf';

  // Call the API
  const response = await fetch('https://docusense.stackapi.dev/api/v1/documents/invoice', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.DOCUSENSE_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ fileBase64: base64, mimeType, language: 'en' })
  });

  const result = await response.json();

  if (!result.success) {
    throw new Error(result.error?.message || 'Extraction failed');
  }

  return result.data;
}

// Usage
const invoice = await extractInvoice('./vendor-invoice.pdf');
console.log(`Total: ${invoice.total} ${invoice.currency}`);
console.log(`Due: ${invoice.dueDate}`);

Python

import base64
import httpx
import os

def extract_invoice(file_path: str) -> dict:
    with open(file_path, "rb") as f:
        base64_content = base64.b64encode(f.read()).decode("utf-8")

    ext = file_path.rsplit(".", 1)[-1].lower()
    mime_types = {"pdf": "application/pdf", "jpg": "image/jpeg", "png": "image/png"}
    mime_type = mime_types.get(ext, "application/pdf")

    response = httpx.post(
        "https://docusense.stackapi.dev/api/v1/documents/invoice",
        headers={
            "Authorization": f"Bearer {os.environ['DOCUSENSE_API_KEY']}",
            "Content-Type": "application/json"
        },
        json={"fileBase64": base64_content, "mimeType": mime_type, "language": "en"},
        timeout=60.0
    )

    result = response.json()
    if not result["success"]:
        raise ValueError(result["error"]["message"])

    return result["data"]

# Usage
invoice = extract_invoice("./vendor-invoice.pdf")
print(f"Invoice #{invoice['invoiceNumber']} — Total: {invoice['total']} {invoice['currency']}")

Real-World Integration: QuickBooks Auto-Entry

Here's a complete example that extracts an invoice and creates a QuickBooks bill automatically:

const QuickBooks = require('node-quickbooks');
const { extractInvoice } = require('./invoice-extractor');

async function processVendorInvoice(invoicePath, vendorId) {
  // Step 1: Extract invoice data
  const invoice = await extractInvoice(invoicePath);

  // Step 2: Map to QuickBooks bill format
  const bill = {
    VendorRef: { value: vendorId },
    TxnDate: invoice.invoiceDate,
    DueDate: invoice.dueDate,
    DocNumber: invoice.invoiceNumber,
    Line: invoice.lineItems.map((item, i) => ({
      Id: String(i + 1),
      Amount: item.amount,
      DetailType: 'AccountBasedExpenseLineDetail',
      AccountBasedExpenseLineDetail: {
        AccountRef: { value: '1' },  // Your expense account
        BillableStatus: 'NotBillable',
        UnitPrice: item.unitPrice,
        Qty: item.quantity
      },
      Description: item.description
    })),
    TotalAmt: invoice.total,
    CurrencyRef: { value: invoice.currency || 'CAD' }
  };

  // Step 3: Create in QuickBooks
  return new Promise((resolve, reject) => {
    qbo.createBill(bill, (err, result) => {
      if (err) reject(err);
      else resolve(result);
    });
  });
}

// Process all invoices in a folder
const invoiceFiles = fs.readdirSync('./inbox').filter(f => f.endsWith('.pdf'));

for (const file of invoiceFiles) {
  try {
    const bill = await processVendorInvoice(`./inbox/${file}`, VENDOR_ID);
    console.log(`✓ Created bill ${bill.DocNumber} — $${bill.TotalAmt}`);
    fs.renameSync(`./inbox/${file}`, `./processed/${file}`);
  } catch (err) {
    console.error(`✗ Failed ${file}:`, err.message);
    fs.renameSync(`./inbox/${file}`, `./errors/${file}`);
  }
}

Handling Different Invoice Formats

The API handles all common formats without any configuration:

Format	Supported	Notes
Digital PDF	✅	Best accuracy
Scanned PDF	✅	Works with most scan qualities
JPEG / PNG	✅	Phone photos work too
French invoices (TVA, TTC)	✅	Pass `language: 'fr'`
Canadian (GST/HST/QST)	✅	Auto-detected
US invoices	✅
European (VAT)	✅

Processing a Folder of Invoices (Batch Approach)

const processInvoiceQueue = async (folderPath) => {
  const files = fs.readdirSync(folderPath)
    .filter(f => ['.pdf', '.jpg', '.png'].includes(path.extname(f).toLowerCase()));

  console.log(`Processing ${files.length} invoices...`);

  const results = await Promise.allSettled(
    files.map(async (file) => {
      const data = await extractInvoice(path.join(folderPath, file));
      return { file, ...data };
    })
  );

  const succeeded = results.filter(r => r.status === 'fulfilled').map(r => r.value);
  const failed = results.filter(r => r.status === 'rejected');

  console.log(`✓ ${succeeded.length} extracted, ✗ ${failed.length} failed`);

  // Export to CSV
  const csv = [
    'File,InvoiceNumber,Date,Vendor,Total,Currency',
    ...succeeded.map(r => 
      `${r.file},${r.invoiceNumber},${r.invoiceDate},"${r.vendor?.name}",${r.total},${r.currency}`
    )
  ].join('\n');

  fs.writeFileSync('./invoices-export.csv', csv);
  return succeeded;
};

Error Handling Best Practices

async function extractInvoiceRobust(filePath, retries = 2) {
  for (let attempt = 0; attempt <= retries; attempt++) {
    try {
      return await extractInvoice(filePath);
    } catch (err) {
      if (attempt === retries) throw err;

      // Retry on timeout or server error
      if (err.message.includes('timed out') || err.status >= 500) {
        console.log(`Retry ${attempt + 1}/${retries} for ${filePath}`);
        await new Promise(r => setTimeout(r, 2000 * (attempt + 1)));
        continue;
      }

      throw err; // Don't retry on validation errors
    }
  }
}

Cost Breakdown

At scale, here's what this costs:

Volume	Manual entry cost*	API cost
100 invoices/month	~$450 (5h × $90/h)	Free tier
1,000 invoices/month	~$4,500	$19/month
10,000 invoices/month	~$45,000	$49/month

*Assuming $90/hour for an accounts payable specialist at 3 min/invoice.

The ROI is obvious at any scale above ~20 invoices/month.

Getting Started

Get a free API key: RapidAPI — DocuSense API
Free tier: 100 extractions/month
No credit card required

# Quick test with curl
curl -X POST https://docusense.stackapi.dev/api/v1/documents/invoice \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"fileBase64\": \"$(base64 -i your-invoice.pdf)\", \"mimeType\": \"application/pdf\"}"

What's Next?

Once you have invoice extraction working, you can extend it to:

Bank statement analysis — categorize transactions, detect patterns
Contract extraction — pull payment terms, dates, party names
T4/W-2 parsing — income verification for lending workflows

All available via the same API.

What's your current invoice processing workflow? Are you still doing it manually, or have you automated it? Share in the comments.

How to Automate Canadian T4 Slip Parsing with an API (No OCR Setup Required)

Adda — Thu, 21 May 2026 02:40:21 +0000

Every year, thousands of mortgage brokers, accountants, and HR professionals in Canada manually re-enter data from T4 slips. Box 14, box 22, box 16, box 18 — copied one by one from a PDF into a spreadsheet or loan application.

It's slow, error-prone, and completely unnecessary in 2025.

In this article, I'll show you how to automate T4 extraction in under 10 minutes using a REST API — no OCR libraries, no ML model, no infrastructure to maintain.

What is a T4 Slip?

A T4 (Statement of Remuneration Paid) is a Canadian tax document issued by employers to employees every year. It reports employment income and all payroll deductions to the CRA.

Key boxes that matter for most workflows:

Box	Description
Box 14	Employment income
Box 16	CPP contributions
Box 17	QPP contributions (Quebec)
Box 18	EI premiums
Box 22	Income tax deducted
Box 24	EI insurable earnings
Box 26	CPP/QPP pensionable earnings

The Problem With Traditional OCR

Most OCR libraries (Tesseract, AWS Textract, Google Document AI) are general-purpose. They extract raw text — but they don't understand that "14" followed by a number means "employment income."

You still end up writing a parser, maintaining regex patterns, and handling every variation of T4 layout across different payroll systems (ADP, Ceridian, Payworks, Nethris...).

A Better Approach: Document Intelligence API

Instead of building and maintaining OCR + parsing logic, you can call an API that handles everything — including scanned T4s.

Here's how it works:

Convert the T4 PDF to base64
Send it to the API
Get back structured JSON with all boxes

Step-by-Step Implementation

Step 1 — Convert the PDF to Base64

Node.js:

const fs = require('fs');

const pdfBuffer = fs.readFileSync('./t4-2024.pdf');
const base64 = pdfBuffer.toString('base64');

Python:

import base64

with open("t4-2024.pdf", "rb") as f:
    base64_str = base64.b64encode(f.read()).decode("utf-8")

PowerShell (Windows):

$base64 = [Convert]::ToBase64String([IO.File]::ReadAllBytes("C:\path\to\t4-2024.pdf"))

Step 2 — Call the API

const response = await fetch('https://docusense.stackapi.dev/api/v1/documents/t4', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    fileBase64: base64,
    mimeType: 'application/pdf',
    taxYear: 2024,
    language: 'fr'  // or 'en'
  })
});

const result = await response.json();
console.log(result.data);

Step 3 — Handle the Response

{
  "success": true,
  "data": {
    "taxYear": 2024,
    "employerName": "Entreprise ABC Inc.",
    "payrollAccountNumber": "123456789RP0001",
    "employeeName": "Jean Tremblay",
    "socialInsuranceNumber": "***-***-456",
    "province": "QC",
    "boxes": {
      "box14": 72000.00,
      "box16": null,
      "box17": 3799.80,
      "box18": 1049.12,
      "box22": 17850.00,
      "box24": 61500.00,
      "box26": 68500.00,
      "box44": null,
      "box46": 500.00
    }
  }
}

Notice that the SIN is automatically masked (***-***-456) — privacy is handled for you.

Real-World Example: Mortgage Pre-Qualification

Here's a complete example that extracts T4 data and calculates whether an applicant qualifies for a mortgage:

async function checkMortgageEligibility(t4PdfPath, propertyPrice, downPayment) {
  // Step 1: Extract T4 data
  const base64 = fs.readFileSync(t4PdfPath).toString('base64');

  const t4Response = await fetch('https://docusense.stackapi.dev/api/v1/documents/t4', {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${process.env.API_KEY}`, 'Content-Type': 'application/json' },
    body: JSON.stringify({ fileBase64: base64, mimeType: 'application/pdf', taxYear: 2024 })
  });

  const { data: t4 } = await t4Response.json();
  const annualIncome = t4.boxes.box14;

  // Step 2: Calculate mortgage using FinGuard API
  const loanAmount = propertyPrice - downPayment;

  const mortgageResponse = await fetch('https://api.stackapi.dev/api/v1/calculators/mortgage', {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${process.env.API_KEY}`, 'Content-Type': 'application/json' },
    body: JSON.stringify({
      loanAmount,
      interestRate: 5.5,
      loanTermYears: 25
    })
  });

  const { data: mortgage } = await mortgageResponse.json();

  // Step 3: Check GDS ratio (should be under 32%)
  const monthlyIncome = annualIncome / 12;
  const gdsRatio = (mortgage.monthlyPayment / monthlyIncome) * 100;

  return {
    employeeName: t4.employeeName,
    annualIncome,
    monthlyPayment: mortgage.monthlyPayment,
    gdsRatio: gdsRatio.toFixed(2),
    eligible: gdsRatio < 32
  };
}

// Usage
const result = await checkMortgageEligibility('./jean-t4.pdf', 450000, 90000);
console.log(result);
// {
//   employeeName: "Jean Tremblay",
//   annualIncome: 72000,
//   monthlyPayment: 2134.50,
//   gdsRatio: "35.57",
//   eligible: false
// }

What About Scanned T4s?

Scanned T4s (image-based PDFs) are handled automatically — no extra configuration needed. The same API call works for both digital and scanned documents.

You can also send image files directly:

// Works with JPG, PNG, WEBP too
body: JSON.stringify({
  fileBase64: base64,
  mimeType: 'image/jpeg',  // or image/png, image/webp
  taxYear: 2024
})

Quebec Specifics: RL-1 Support

If you work with Quebec employees, you'll also need to process RL-1 slips (Relevé 1 from Revenu Québec). The same approach works:

const rl1Response = await fetch('https://docusense.stackapi.dev/api/v1/documents/rl1', {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${process.env.API_KEY}`, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    fileBase64: base64,
    mimeType: 'application/pdf',
    taxYear: 2024,
    language: 'fr'
  })
});

Returns all RL-1 cases: A (employment income), B (QPP), C (EI), E (Quebec tax withheld), G (QPP admissible salary), H/I (QPIP)...

Getting Started

Sign up for a free API key at RapidAPI — DocuSense API
The free tier includes 100 documents/month — enough to test thoroughly
T4 extraction requires the PRO plan ($19/month)

Summary

Approach	Setup time	Maintenance	Scanned PDFs
Tesseract OCR + custom parser	2-3 days	High	Poor
AWS Textract	1 day	Medium	Good
Google Document AI	1 day	Medium	Good
DocuSense API	10 minutes	Zero	Yes

If you're building any Canadian fintech workflow that touches T4s — mortgage applications, payroll software, accounting tools, income verification — this will save you significant development and maintenance time.

Have questions about the API or want to share what you're building? Drop a comment below.