Foreign-Currency AR Aging Automation in 2026: Invoice-Date Rates, Payment-Date Checks, and Collections Queues

The work is not only currency math. Finance needs to know which date policy was used, whether a payment-date recheck changed the collection priority, and which invoices need human review before a reminder is sent. RevOps needs the same output in customer health views, renewal calls, and account escalations. Engineering needs a job that can process many invoices without hiding retries or burning through API usage unexpectedly.

Currency-Exchange.app verifies REST endpoints for conversion, spot rate lookup, currency details, currency listing, and usage reporting. The conversion response includes the resolved exchange rate, rateTime, original amount, converted amount, and converted text. The rate lookup response includes inverseRate and a disclaimer. Those fields are enough to build an API-based AR aging control without claiming a native ERP or collections integration.

Why AR Aging Breaks in Multi-Currency Teams

A domestic aging report usually argues about due dates, disputed invoices, and collection ownership. A multi-currency aging report adds another layer: what currency should be shown, which exchange date is correct, and whether the amount changed because the customer paid late or because the reporting rate moved. If those assumptions are not stored, every reviewer rebuilds the logic from memory.

This becomes especially painful in B2B SaaS and services businesses where renewals, partial payments, credits, and payment plans can touch the same account. Sales wants a clean customer balance before a renewal call. Collections wants to prioritize the largest overdue exposure. Accounting wants the close package to match the policy used last month. Engineering wants one repeatable job, not three teams exporting their own CSV files.

The automation goal is not to remove judgment. It is to make the rate choice, date choice, and exception reason visible before someone contacts the customer. That keeps the workflow useful for finance and safe for customer-facing teams.

The AR Aging Workflow

Aging Buckets Need Different Controls

Minimum Data Model for an Explainable AR Run

Keep the AR table intentionally explicit. If the invoice date, policy date, and payment date share one column, the report becomes hard to audit. If the converted amount is stored without rateTime, the number cannot be reproduced. If the run ID is missing, finance cannot connect an exception row to the job that created it.

API Examples for Receivables Teams

Use one run ID for the whole aging job. Every conversion row should include that ID so finance can replay the file and engineering can compare row counts with usage records.

Convert an open invoice using the invoice date

curl "https://api.currency-exchange.app/v1-convert-currency?from=EUR&to=USD&amount=18400&date=2026-04-30&getPerformanceData=true" \
  -H "x-api-key: YOUR_API_KEY"

Example conversion response shape

{
  "from": "EUR",
  "to": "USD",
  "exchangeRate": 1.0842,
  "rateTime": "2026-04-30T23:59:59.000Z",
  "originalAmount": 18400,
  "convertedAmount": 19949.28,
  "convertedText": "18400 EUR equal to 19949.28 USD",
  "provider": "pagesdev",
  "cached": false
}

Recheck payment-date rate for variance review

curl "https://api.currency-exchange.app/v1-get-currency-exchange-rate?from=EUR&to=USD&date=2026-05-21&skipCache=true&cacheTimeSeconds=0" \
  -H "x-api-key: YOUR_API_KEY"

Validate the currency before the run

curl "https://api.currency-exchange.app/v1-get-currency-details?code=EUR&expand[]=units" \
  -H "x-api-key: YOUR_API_KEY"

Review usage after the AR job

curl "https://api.currency-exchange.app/v1-get-api-usage?from=2026-05-01&to=2026-05-21&service=currency" \
  -H "x-api-key: YOUR_API_KEY"

A TypeScript Worker Pattern

This worker converts one invoice row and assigns an aging bucket. In production, wrap it in your queue, spreadsheet automation, or warehouse job; throttle requests; and record rate-limit headers if the platform running the job exposes them.

type ArInvoice = {
  invoiceId: string;
  customerId: string;
  invoiceCurrency: string;
  functionalCurrency: string;
  invoiceDate: string;
  dueDate: string;
  openAmount: number;
};

type AgingRow = ArInvoice & {
  requestedAt: string;
  exchangeRate: number;
  rateTime: string;
  functionalOpenAmount: number;
  bucket: 'current' | '1-30' | '31-60' | '61-90' | '90-plus';
  reviewReason?: string;
};

function getAgingBucket(dueDate: string, asOfDate: string): AgingRow['bucket'] {
  const daysPastDue = Math.floor((Date.parse(asOfDate) - Date.parse(dueDate)) / 86_400_000);

  if (daysPastDue <= 0) {
    return 'current';
  }

  if (daysPastDue <= 30) {
    return '1-30';
  }

  if (daysPastDue <= 60) {
    return '31-60';
  }

  if (daysPastDue <= 90) {
    return '61-90';
  }

  return '90-plus';
}

export async function buildAgingRow(invoice: ArInvoice, asOfDate: string): Promise<AgingRow> {
  const requestedAt = new Date().toISOString();
  const url = new URL('https://api.currency-exchange.app/v1-convert-currency');
  url.searchParams.set('from', invoice.invoiceCurrency);
  url.searchParams.set('to', invoice.functionalCurrency);
  url.searchParams.set('amount', String(invoice.openAmount));
  url.searchParams.set('date', invoice.invoiceDate);
  url.searchParams.set('getPerformanceData', 'true');

  const response = await fetch(url, {
    headers: { 'x-api-key': process.env.currencyExchangeApiKey ?? '' },
  });

  if (!response.ok) {
    throw new Error(`AR conversion failed for invoice ${invoice.invoiceId}`);
  }

  const data = (await response.json()) as {
    exchangeRate: number;
    rateTime: string;
    convertedAmount: number;
  };

  const bucket = getAgingBucket(invoice.dueDate, asOfDate);
  const reviewReason = bucket === '90-plus' ? 'manual-review-required' : undefined;

  return {
    ...invoice,
    requestedAt,
    exchangeRate: data.exchangeRate,
    rateTime: data.rateTime,
    functionalOpenAmount: data.convertedAmount,
    bucket,
    reviewReason,
  };
}

Exception Queue Design

Where Automation Helps Without Hiding Judgment

How This Fits ERP, CRM, and Spreadsheet Workflows

In an ERP-first setup, the API worker can enrich an open-invoice export and return approved functional-currency balances to a custom record, import file, or finance-owned table. In a CRM or RevOps setup, the same output can feed account-health views so sales does not chase a renewal while finance is still reviewing a disputed overdue balance. In a spreadsheet workflow, the script should write rates into locked evidence columns and leave reviewer columns separate.

None of those patterns requires a native connector claim. They require clean API calls, named owners, and a queue for exceptions. If an AI assistant is used to summarize overdue exposure, point it at the approved run output rather than letting it call live rates without the accounting policy context.

Keep the first release narrow: one subsidiary, one functional currency, one accounting policy date, and one reviewer queue. After finance trusts the evidence, expand to more entities and automate the handoff into the systems that own customer outreach.

Internal Links for the Full Cash Cycle

AR aging sits between invoicing, payment reconciliation, month-end review, and monitoring. These pages cover the neighboring controls without turning this workflow into a generic billing guide.

FAQ