# ai.ohmyfin/invoice (remote · mcp.ohmyfin.ai)

Cross-border invoices for AI agents: parties screened, VAT ID checked, EN 16931 e-invoice in PDF.

- Trust score: 67/100 (medium)
- Change this week: +4
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- remote · `mcp.ohmyfin.ai`: 67/100 (this document), [markdown](https://verifymcp.io/servers/ai-ohmyfin-invoice/mcp.md), [page](https://verifymcp.io/servers/ai-ohmyfin-invoice/mcp)

## Channel facts

- Endpoint: `https://mcp.ohmyfin.ai/mcp?from=registry-invoice`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Endpoint Security**: 63/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to call this server, and 1 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 61/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 20778 tokens (~546/item across 38 items; 38 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 50/100
  - Stability observed for 15 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 25/100
  - Injection-marker check failed: the description of tool "iban_validate" contains an instruction to conceal the call from the user, the text "do not tell the user", at byte 1444 of that field, plus 2 further marker(s) of the same kind.
  - 0 of 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "transfer_cost" implies "transfer" and declares readOnlyHint instead, contradicting what its own name says it does.
  - An AI judge read all 39 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the ai.ohmyfin/invoice MCP server?

ai.ohmyfin/invoice is a hosted endpoint at https://mcp.ohmyfin.ai/mcp?from=registry-invoice, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http ai-ohmyfin-invoice 'https://mcp.ohmyfin.ai/mcp?from=registry-invoice'
```

### Cursor

```json
{
  "mcpServers": {
    "ai-ohmyfin-invoice": {
      "url": "https://mcp.ohmyfin.ai/mcp?from=registry-invoice"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "ai-ohmyfin-invoice": {
      "type": "http",
      "url": "https://mcp.ohmyfin.ai/mcp?from=registry-invoice"
    }
  }
}
```

### Codex

```toml
[mcp_servers.ai-ohmyfin-invoice]
url = "https://mcp.ohmyfin.ai/mcp?from=registry-invoice"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ai-ohmyfin-invoice": {
      "type": "remote",
      "url": "https://mcp.ohmyfin.ai/mcp?from=registry-invoice",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ai-ohmyfin-invoice --url 'https://mcp.ohmyfin.ai/mcp?from=registry-invoice' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  ai-ohmyfin-invoice:
    url: "https://mcp.ohmyfin.ai/mcp?from=registry-invoice"
```

### Netclaw

```json
{
  "McpServers": {
    "ai-ohmyfin-invoice": {
      "Transport": "http",
      "Url": "https://mcp.ohmyfin.ai/mcp?from=registry-invoice"
    }
  }
}
```

### Vellum

```bash
assistant mcp add ai-ohmyfin-invoice -t streamable-http -u 'https://mcp.ohmyfin.ai/mcp?from=registry-invoice'
```

### Other

```json
{
  "mcpServers": {
    "ai-ohmyfin-invoice": {
      "type": "http",
      "url": "https://mcp.ohmyfin.ai/mcp?from=registry-invoice"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-21 (score 67, +1)

- [security] Tool “crypto_wallet_screen” rewrote its description, which is the text the model reads
- [cosmetic] “swift_lookup” added an optional parameter “details_section_page”

### 2026-11-20 (score 66, 0)

- [cosmetic] “country_payment_codes” added an optional parameter “page”
- [cosmetic] “payment_cutoff_times” added an optional parameter “page”
- [cosmetic] “swift_lookup” added an optional parameter “details_section”
- [cosmetic] “swift_lookup” added an optional parameter “page”

### 2026-11-19 (score 66, +1)

- [security] Tool “sanctions_screen” rewrote its description, which is the text the model reads
- [functional] New tool “crypto_wallet_report”
- [functional] New tool “crypto_wallet_result”
- [functional] New tool “crypto_wallet_screen”

### 2026-11-17 (score 65, +1)

No change was recorded against any check on this day. Stability & Change Management went from 33 to 37. That category is still filling its 30-day observation window: 10 days of observed history at the previous scan, 11 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-16 (score 64, 0)

- [security] Tool “sanctions_screen” rewrote its description, which is the text the model reads
- [security] Tool “ssi_lookup” rewrote its description, which is the text the model reads
- [cosmetic] “settlement_eta” reworded the description of “currency”

### 2026-11-15 (score 64, +1)

No change was recorded against any check on this day. Stability & Change Management went from 27 to 30. That category is still filling its 30-day observation window: 8 days of observed history at the previous scan, 9 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-13 (score 63, +1)

- [functional] MCP protocol: Implements a current MCP spec version (2026-07-28).
- [functional] MCP protocol version: 2025-11-25 → 2026-07-28

### 2026-11-11 (score 62, 0)

- [functional] Server version: 3.1.0 → 4.1.4
- [functional] New tool “my_tracked_payments”

## MCP tools (38)

### `swift_lookup` (~951 tokens)

Bank and BIC Directory Search

Search banks and financial institutions by name, SWIFT/BIC code, or country.

Covers both SWIFT-connected banks and non-SWIFT financial institutions
(e-money issuers, payment processors, MFOs, brokerages, VASPs, etc.).

Returns: SWIFT/BIC code (if any), name, city, country, institution type,
GPI membership, a coarse sanctions FLAG across 7 hard-sanctions watchlists
(OFAC SDN, EU, UK, CA, CH, AU, NZ — see sanctions_note; this is NOT a full
screen, use sanctions_screen for a compliance verdict), and enriched bank
profile when available.

EVERY BANK COMES BACK SAYING WHETHER WE HOLD ITS CORRESPONDENT CHAIN.
Read `settlement_instructions` on each bank: `on_file: true` with a
\`currencies_on_file` count means we hold that BIC8's actual correspondent
BIC, nostro account number and national clearing ID, and `read_with` is the
exact ssi_lookup call that returns them. `on_file: false` means we hold none
in any currency — a gap in our data, not a finding about the bank. A null is
"not established yet" and is neither. This is the answer to "which
intermediary bank do I put on the instruction?", and it is a fact we either
have or do not have — never one to recall from training data.

A BIC IDENTIFIES AN OFFICE, NOT A BRAND, AND THE DIFFERENCE IS PRICED.
A name search returns ONE representative office per bank, elected by BIC
convention rather than by relevance to the payment, and `office_note` says
so whenever the bank holds more than one. Published tariffs, correspondent
chains and settlement instructions are filed per BIC, so the choice changes
the answer: transfer_cost("COBADEFF") returns Commerzbank's published 0.15%
sending fee and transfer_cost("COBADEBB") refuses for want of a filed
tariff, and both of those are Commerzbank AG in Germany. So:
  \- If the user named a CITY, put it in the query — "Commerzbank Frankfurt"
    resolves to the Frankfurt office, and the plain name cannot.
  \- If they did not, ask which BIC is on their statement or payment
    instruction before…

Input parameters:

- `country`: Optional country filter: an ISO 3166-1 alpha-2 code ("ID", "DE") or a full English name ("Indonesia", "Germany"). Names are resolved automatically.
- `details_section`: Optional name of one research-profile section to return in full, as listed in a bank's `details_left_out` (e.g. "official_documents" or a details_raw section name). Omit it for the normal answer.
- `details_section_page` (integer): Optional page of the details_section, from 1 (default). Used only when an answer says that section comes in pages and names the page that holds the rest.
- `limit` (integer): Maximum number of banks to return, 1-100 (default 20). Values outside the range are clamped.
- `page` (integer): Optional page of the matched banks, from 1 (default). Used only when an answer says banks were left out to fit and names the page that holds them.
- `query` (string, required): Bank name, BIC, or bank name plus city ("Commerzbank Frankfurt"). A BIC may be 8 or 11 characters; an 11-character BIC ending in XXX is searched as its 8-character form. The 12-character address in a…

### `iban_validate` (~551 tokens)

IBAN Validation

Validate an IBAN and identify the institution that holds the account.

Performs format check, country-specific length check, and
ISO 7064 mod-97 checksum verification. Also returns COUNTRY-level
banking rules for the IBAN's country prefix (national currency,
SEPA status, expected format).

CROSS-CHECKS THE BENEFICIARY BANK. Where the country's IBAN registry
mask defines the bank identifier as four alpha characters (GB, NL, IE,
RO, PK, MT, JO, QA, KW and others), `bank_identifier.resolved_institution`
names the institution that actually holds the account, read out of the
IBAN itself. Call this whenever the user supplies an IBAN AND names a
beneficiary bank or BIC — if the two disagree, that mismatch is a far
better explanation for a rejected or returned payment than anything you
can infer, and it is invisible without this call. Everywhere else the
bank identifier is a NATIONAL bank/sort code (the German BLZ, Italian
ABI, French code banque): `bank_identifier.code` is those characters,
\`is_bic_prefix` is false, and no institution is named — quote the code
when telling the user what to check, never a bank name derived from it.

A FAILURE IS NOT ALWAYS A CHECKSUM FAILURE. An IBAN of the right length
whose characters break the country's mask (a letter where the country
requires a digit — O for 0, I for 1) is refused BEFORE mod-97 runs, with
\`format_violations` naming the position. Report the position and the
character; do not tell the user the check digits are wrong.

\`valid: true` means the check digits are right and NOTHING MORE — not
that the account exists, is open, or belongs to the named beneficiary or
the named bank. Never rule out the account details on the strength of it
when diagnosing a failed payment (see `verification_note`).

An IBAN encodes country + bank + account number and carries NO
currency information. `country_currency` is the country's national
currency, NOT this account's denomination — never infer a currency
mismatch or a "resend in X" recommend…

Input parameters:

- `iban` (string, required): The IBAN to check, e.g. "DE89370400440532013000". Spaces and hyphens are ignored and letters are upper-cased.

### `country_banking_rules` (~406 tokens)

Country Banking Rules

Get banking rules and requirements for a country.

Returns IBAN requirements, SEPA membership, FATF listing status,
national currency, account format specifications, and country-specific
payment requirements (mandatory codes like KNP for Kazakhstan,
Purpose of Payment for UAE, etc.).

The `fatf_listing` block is the authoritative answer to "is this country
grey-listed / black-listed / under FATF increased monitoring". Both FATF
public lists are held in full, so a `not_listed` status is a positive
determination and not missing data. Use it instead of training data for any
FATF question, and note that the coarse `fatf` field is a separate, weaker
signal about regional-body membership that says nothing about listing.

Everything here is COUNTRY-level. `currency` is the country's national
currency, not the denomination of any beneficiary account — never pair it
with the payment currency to diagnose a currency mismatch (see
\`currency_note` in the response).

Use this to check country-specific STP rules that could cause payment delays, repairs, or rejections (e.g., missing purpose codes, regulatory fields).

\`payment_code_requirement.required` is what our data holds on country-specific
purpose / payment codes: true (a requirement is on file; payment_requirements
lists the code tables when we hold them), false (our profile states that none
is imposed), "conditional", or "unknown" (not covered: an absence of data,
never a finding that no code is required). Use country_payment_codes to look
up specific code values.

Examples:
  country_banking_rules("DE")
  country_banking_rules("KZ")   # includes KNP requirement info
  country_banking_rules("AE")   # includes Purpose of Payment info

Input parameters:

- `country_code` (string, required): ISO 3166-1 alpha-2 country code, e.g. "DE", "US", "KZ".

### `country_payment_codes` (~273 tokens)

Country Payment Codes

Look up country-specific payment codes (KNP, purpose codes, etc.).

Use country_banking_rules first to see which code types a country
requires (in the payment_requirements block), then use this tool
to find the right code value.

Examples:
  country_payment_codes("KZ", "knp", "transport")
  country_payment_codes("KZ", "knp", "insurance")
  country_payment_codes("AE", "purpose_code", "trade")
  country_payment_codes("KZ", "knp")   # all codes (large response)

Input parameters:

- `code_type` (string, required): Which code table to search, as named in country_banking_rules payment_requirements.required_fields[].code_type (e.g. "knp", "purpose_code"). Case-insensitive.
- `country_code` (string, required): ISO 3166-1 alpha-2 country code, e.g. "KZ", "AE".
- `page` (integer): Optional page of the codes, from 1 (default). Used only when an answer says codes were left out to fit and names the page that holds them.
- `search`: Optional keyword filter (e.g. "transport", "trade", "insurance"). Omit it to list every code in the table, which is a large response.

### `fx_rate` (~403 tokens)

FX Reference Rate

Get the latest available reference (mid-market) exchange rate for a pair.

Rates are the official ECB euro foreign-exchange reference rates where the
ECB publishes the currency; pairs whose currency the ECB does not cover
(e.g. VND, NGN, PKR, KZT, MAD) fall back to a market data feed. ALWAYS
check the `source` field before describing provenance: "ecb" = official
ECB reference rate; "market" = indicative mid-market rate, NOT an ECB
fixing — never call it "the ECB rate". The `source_note` field in the
result states this explicitly. Coverage is wide (~60 currencies) but NOT
universal — some currencies (e.g. CLP, COP, PEN) have no rate on file at
all. When a leg is missing, the error names exactly which currency is
uncovered: relay that we hold no rate rather than supplying one from your
own knowledge. Non-EUR pairs are
computed as cross-rates via EUR (e.g., USD/GBP = EUR/GBP / EUR/USD), so
they are indicative mid-rates, not dealable/executable rates.

BOTH currencies are required. Always pass the exact pair you intend.
There is no implicit default pair: a call that omits or mis-names a
currency returns a "missing required argument" error rather than a
silently-wrong rate. Never assume EUR/USD when the user asked about a
different pair such as USD/VND.

Examples:
  fx_rate("EUR", "USD")
  fx_rate("GBP", "JPY")
  fx_rate("USD", "VND")

Input parameters:

- `base` (string, required): Base currency, ISO 4217 (e.g. "USD"). The rate is quoted as units of target per 1 base.
- `target` (string, required): Target currency, ISO 4217 (e.g. "VND").

### `fx_rate_history` (~531 tokens)

FX Rate History

Get the historical reference exchange-rate series for a currency pair.

Returns `series` (the daily rates) plus the metadata needed to describe it
honestly. READ `series_coverage` BEFORE CHARACTERISING THE PERIOD. `days`
is the window we look back over, NOT a promise of how much history exists:
our series start at different dates per currency, so a 365-day request
routinely returns five months. `series_coverage.first_date`/`last_date` are
what the numbers actually span, and `series_coverage.truncated` is true
when that is shorter than you asked for. Say "the ~N months we hold", never
"over the past year", and never fill the gap from your own knowledge.

CHECK `source` BEFORE ATTRIBUTING PROVENANCE. "ecb" = official ECB euro
reference fixings, weekdays only. "market" = an indicative market data feed
for a currency the ECB does not publish (AED, QAR, SAR, KWD, NGN, PKR, VND,
KZT, RUB, UAH and ~20 more). A market series is NOT an ECB series and must
never be described as one. Where a pair mixes the two, `series_coverage`
reports the dates lost to aligning them.

\`peg_context` appears when either currency is pegged, including when the
peg is against some third currency: it names the anchor and the pair whose
movement you are really looking at. Take the peg date from there rather
than from memory.

An uncovered pair returns an `error` naming the missing leg instead of an
empty series. Report that we hold no history rather than describing the
rate as stable or range-bound.

BOTH currencies are required. Always pass the exact pair you intend.
There is no implicit EUR/USD default: an omitted or mis-named currency
errors rather than returning the wrong pair's history.

Examples:
  fx_rate_history("EUR", "USD", 30)
  fx_rate_history("GBP", "CHF", 365)

Input parameters:

- `base` (string, required): Base currency, ISO 4217 (e.g. "EUR"). Rates are quoted as units of target per 1 base.
- `days` (integer): Lookback window in calendar days, 1-365 (default 90). Values outside the range are clamped. A ceiling on the window, not a promise of that many data points.
- `target` (string, required): Target currency, ISO 4217 (e.g. "USD").

### `gpi_status_codes` (~603 tokens)

Payment Status Codes and Stuck-Payment Playbooks

Explain SWIFT GPI tracking status codes and provide stuck-payment investigation guidance.

USE THIS TOOL FIRST whenever the user reports a payment that is stuck,
delayed, not arriving, held, pending, rejected, or otherwise not
behaving as expected. It is the primary diagnostic entrypoint for
payment investigation — calling with a specific code returns a
full investigation playbook (common delay causes, recommended
actions, GPI SLA timeframes, escalation steps).

Recommended calls by scenario:
  \- Payment "stuck" / "in progress" / "pending" / "not arrived":
      gpi_status_codes("ACSP")   → playbook for in-progress payments
  \- Payment explicitly "on hold" / compliance review:
      gpi_status_codes("PDNG")   → playbook for held payments
  \- Payment "blocked" / sanctions flag:
      gpi_status_codes("BLCK")   → playbook for blocked payments
  \- Payment rejected by a bank in the chain (never credited):
      gpi_status_codes("RJCT")   → rejection investigation playbook
  \- Payment returned to sender (accepted then sent back):
      gpi_status_codes("RTRN")   → return investigation playbook
  \- Reference for ISO 20022 codes:
      gpi_status_codes()         → list all codes

Each code call returns:
  \- Code description and meaning
  \- For ACSP/PDNG/BLCK/RJCT/RTRN: investigation playbook with common
    causes, recommended actions (request gCCT tracker, request
    pacs.002/pacs.004 reason code, verify beneficiary details,
    escalate via MT199, etc.), and common ISO 20022 reason codes
    (AC01, AC04, AG01, RR01-RR04, etc.) when applicable
  \- Child reason codes (e.g., G001-G004 for ACSP) that narrow the
    cause further

Common codes: ACCC (success), ACSP (in progress), RJCT (rejected),
PDNG (on hold), BLCK (blocked). GPI reason codes (G000-G004) qualify
ACSP with more detail (e.g. G001 = passed on to a bank that is not a
gpi member, G002 = credit pending, may not be same day).

Examples:
  gpi_status_codes("ACSP")   # stuck-payment diagnostic playbook
  gpi_statu…

Input parameters:

- `code`: Optional ISO 20022 status code (ACSP, ACCC, PDNG, RJCT, RTRN, BLCK) or reason code (e.g. G001), case-insensitive. A status code returns its investigation playbook. Omit it to list every code.

Output parameters:

- `result`

### `swift_message_reference` (~255 tokens)

Payment Message Reference (MT and ISO 20022)

Look up SWIFT message types — MT (FIN) and MX (ISO 20022).

Pass a specific type to get full details, or omit to list all types.
Covers customer payments (MT103, pacs.008), FI transfers (MT202,
pacs.009), trade finance (MT700, MT760), cash management (MT940,
camt.053), and payment status (pacs.002).

Also use this tool to answer questions about where specific payment
fields live — e.g., where the UETR sits in an MT103 (Field 121, Block 3
header), where charges appear (71A/71F/71G), or which fields carry
routing info (56/57). MT103 and pacs.008 responses include a
\`tracing_note` explaining UETR recovery for customers who only have
a reference number.

Examples:
  swift_message_reference("MT103")
  swift_message_reference("pacs.008")
  swift_message_reference()

Input parameters:

- `message_type`: Optional message type, e.g. "MT103", "pacs.008", "MT940". Case-insensitive. Omit it to list every type.

Output parameters:

- `result`

### `payment_cutoff_times` (~432 tokens)

Clearing System Cutoff Times

Get payment system cutoff times for major clearing systems.

Covers RTGS (T2 — formerly TARGET2, CHAPS, Fedwire, BOJ-NET, SIC),
net settlement (CHIPS, BACS), SEPA schemes (SCT, SCT Inst, OCT Inst,
SDD Core, SDD B2B), FX settlement (CLS, FXYCS), and other systems
(CIPS, SPEI, FAST).

For same-day EUR guidance: filter by currency="EUR" to retrieve all
SEPA schemes plus T2 in one call — the scheme-level view is usually
what treasurers need. Underlying CSMs (TIPS, RT1, EURO1, STEP2) are
referenced in scheme notes.

DST-observing systems also carry `season_now` and `operative_cutoff_today`
fields computed for the current date. cutoff_utc/cutoff_local are the
STANDARD-TIME (winter) values; summer_offset holds the DST value. Quote the
cutoff that `operative_cutoff_today` points at for TODAY's season — do not
default to the winter figure when DST is currently in force (e.g. the T2
customer cutoff is 15:00 UTC in summer, not the 16:00 UTC winter value).

Examples:
  payment_cutoff_times(system="T2")
  payment_cutoff_times(currency="EUR")
  payment_cutoff_times(currency="USD")
  payment_cutoff_times()

Input parameters:

- `currency`: Optional ISO 4217 code to filter by (e.g. "USD", "EUR").
- `page` (integer): Optional page of the systems, from 1 (default). Used only when an answer says systems were left out to fit and names the page that holds them.
- `system`: Optional clearing system code or name, e.g. "T2", "FEDWIRE", "CHAPS". Case-insensitive; "TARGET2" resolves to T2, its name since March 2023. Omit it to list every system or to filter by currency.

Output parameters:

- `result`

### `fx_volatility` (~671 tokens)

FX Volatility and Exposure Band

Get realized FX volatility for a currency pair, and size the FX risk on an exposure held to a future date.

Computes 30-day and 90-day annualized volatility from historical
ECB reference rates (standard deviation of daily log returns,
annualized by sqrt(252)). Returns a qualitative bucket:
LOW (<5%), MEDIUM (5-15%), HIGH (15-25%), VERY_HIGH (>25%),
PEGGED (currency peg — near-zero volatility, e.g., USD/AED, USD/HKD).

Also returns practical daily/weekly movement estimates and a
settlement_risk_note explaining what the volatility means over a
typical T+2 settlement period — use these to advise users on FX
risk for their specific payment.

PASS horizon_days WHENEVER THE USER'S EXPOSURE RUNS PAST SETTLEMENT.
It returns a `horizon` block: the volatility scaled to that horizon as an
actual rate band at 1 and 2 sigma, which end of the band hurts a payer
versus a receiver, and what the band does and does not tell them about
hedging. Use it for questions shaped like:
  \- "should I hedge / lock in / take a forward for <future period>?"
  \- "how far could <pair> move by <date>?"
  \- "what rate should I budget for next year?"
  \- "I have invoices in <currency> through 2027 — what is my risk?"
  \- any exposure not settling within a few days.
Count the calendar days from today to the date the exposure ends and pass
that. Rough is fine — the band moves with the square root of time, so a
month either way barely changes it.

Read `sample_depth` before quoting any figure: this is REALISED volatility
from a short history, not implied volatility, and the sample may be shorter
than the horizon asked about (`horizon.beyond_sample`). Say so.

IMPORTANT — the band is the range of FUTURE SPOT. It is not a rate anyone
can transact at, and the width of the band is NOT the cost of a hedge. A
forward is priced off the interest-rate differential between the two
currencies, which we do not hold and must not guess or recall from memory.
Relay `horizon.hedge_cost_note` rather than inventing forwa…

Input parameters:

- `base` (string, required): Base currency, ISO 4217 (e.g. "EUR").
- `horizon_days`: Optional. Calendar days from today to the end of the exposure, 1-1825. A value outside that range returns an error instead of a band. Omit it for spot / settlement risk only.
- `target` (string, required): Target currency, ISO 4217 (e.g. "TRY").

### `fx_timing_advisor` (~353 tokens)

FX Market Session Timing

Get FX trading windows for FX execution timing and spread / rate optimization.

Returns market sessions and liquidity windows for a currency. Use this
to understand:
\- **Rate optimization** (primary, reliable use): higher liquidity means
  tighter spreads and better rates. Execute during peak windows to minimize
  conversion costs.
\- **Delay diagnosis** (use with care): the FX market session is when a
  currency TRADES. It is NOT a guaranteed processing schedule for an inbound
  foreign-currency payment that the beneficiary bank converts on arrival.
  Conversion timing is beneficiary-bank-specific (some convert in real time
  during the session, others batch once or twice daily), so do NOT tell the
  user a payment is "held until the next session" and do not quote specific
  hold durations ("adds X hours", "overnight delay"); those are bank policy
  and are not in our data. For the binding delivery-side cutoff that gates the
  converted local-currency leg, call country_banking_rules(destination) and
  read local_clearing.systems. When a currency is restricted, this tool's own
  output carries an inbound_processing_note with the accurate framing to quote.

Pass a currency code to get its optimal window, or omit to get
all market sessions and overlap windows.

Examples:
  fx_timing_advisor("EUR")
  fx_timing_advisor("JPY")
  fx_timing_advisor("INR")  # Check INR conversion windows
  fx_timing_advisor()

Input parameters:

- `currency`: Optional ISO 4217 code (e.g. "EUR", "JPY"). Omit it to get every session and overlap.

### `payment_method_compare` (~240 tokens)

Payment Method Comparison

Compare payment methods and investigate fee deductions for a country pair.

Evaluates SEPA vs SWIFT vs domestic options. Also explains SWIFT charge
options (OUR/SHA/BEN) and fee investigation — use this when the beneficiary
received less than expected to understand where the money went and which
MT103 fields reveal each deduction. Returns cost, speed, requirements,
charge options, and step-by-step fee investigation guidance.

Examples:
  payment_method_compare("DE", "FR")   # Both SEPA — will recommend SCT
  payment_method_compare("US", "TR")   # Non-SEPA — will recommend SWIFT
  payment_method_compare("GB", "GB")   # Domestic — will show CHAPS/FPS
  payment_method_compare("US", "VN")   # Fee investigation — why beneficiary got less

Input parameters:

- `dest_country` (string, required): Receiving country, ISO 3166-1 alpha-2 country code (e.g. "GB", "TR").
- `source_country` (string, required): Sending country, ISO 3166-1 alpha-2 country code (e.g. "DE", "US").

### `bank_holidays` (~430 tokens)

Bank Holidays

Get bank/public holidays for a country with payment impact analysis.

Returns all public holidays plus a 'payment_impact' section that shows:
\- Whether today is a business day or holiday in this country
\- Upcoming holidays in the next 14 days
\- Recent holidays in the last 14 days — for diagnosing a payment that is
  ALREADY stuck ("in progress for N days", "sent X days ago"). A recent
  holiday only counts if BOTH hold: it falls INSIDE the payment's own
  window (on or after the send date), AND its 'costs_a_business_day' is
  true. One that predates the send date is irrelevant, and one on the
  country's banking weekend closed nothing that was open — neither may be
  subtracted or given to the user as a cause. An empty list affirmatively
  means no recent holiday explains the delay — do not invent one from
  training data.
\- Every holiday entry (upcoming, recent, and next_holiday_after_today)
  carries 'costs_a_business_day'. Roughly one holiday date in six lands on
  its own country's weekend and shortens nothing; check the flag before
  quoting a holiday as a delay, a closure or a reason a window was short.
\- elapsed_business_days_by_send_date — the AUTHORITATIVE elapsed
  business-day count keyed by send date (weekends + this country's
  holidays already excluded). Use it verbatim instead of hand-counting.
\- Next business day and how many consecutive non-business days remain
This context helps determine if holidays are causing payment delays.

Examples:
  bank_holidays("US")
  bank_holidays("DE", 2026)
  bank_holidays("GB", 2025)

Input parameters:

- `country_code` (string, required): ISO 3166-1 alpha-2 country code, e.g. "US", "DE", "GB".
- `year`: Calendar year, 2020-2030 (default: the current year). Values outside the range are clamped.

### `is_business_day_check` (~258 tokens)

Business Day Check

Check if a specific date is a business day in a country.

Accounts for weekends (country-specific) and public holidays.
Returns whether the date is a business day, and if not, why
(weekend or specific holiday name) and the next business day.

The response carries a `today` block with the server's real current date.
Resolve any relative date in the user's question ("the 20th", "next
Friday") against that, not against your own sense of today. A check_date
already in the past also returns `date_anchor_warning` — heed it: a
mis-resolved year flips the answer outright (2025-07-20 is a Sunday,
2026-08-20 is a Thursday).

Examples:
  is_business_day_check("US", "2026-12-25")
  is_business_day_check("DE", "2026-03-12")
  is_business_day_check("GB", "2026-01-01")

Input parameters:

- `check_date` (string, required): The date to check, YYYY-MM-DD (ISO 8601).
- `country_code` (string, required): ISO 3166-1 alpha-2 country code, e.g. "US", "DE".

### `value_date` (~406 tokens)

Value Date Calculator

Calculate the value/settlement date for a payment.

Determines when a payment will settle based on:
\- Source and destination country holiday calendars
\- Weekend conventions (Sat/Sun or Fri/Sat)
\- Currency center holidays (if FX conversion involved)
\- Settlement convention (T+0, T+1, T+2)

Examples:
  value_date("US", "DE")
  value_date("US", "DE", "fx_spot", "USD", "EUR")
  value_date("DE", "FR", "sepa")
  value_date("US", "US", "wire", from_date="2026-07-03")

Input parameters:

- `base_currency`: Base currency for FX, ISO 4217 (e.g. "USD"). Required when settlement_type is "fx_spot".
- `dest_country` (string, required): Receiver's country, ISO 3166-1 alpha-2 country code (e.g. "DE").
- `from_date`: Start date, YYYY-MM-DD (default: today). You do not know today's date: omit this argument unless the user named a specific send date. If the user's date is relative ("the 20th", "next Friday", "month…
- `settlement_type` (string): One of "wire" (T+0 domestic / T+1 international, the default), "fx_spot" (T+1 or T+2 depending on the pair), "sepa" (D+1), "sepa_instant" (T+0).
- `source_country` (string, required): Sender's country, ISO 3166-1 alpha-2 country code (e.g. "US").
- `target_currency`: Target currency for FX, ISO 4217 (e.g. "EUR"). Required when settlement_type is "fx_spot".

### `settlement_eta` (~1242 tokens)

Payment Arrival Estimate (Beta)

BETA. Estimate when a SWIFT payment will arrive: a corpus-grounded
arrival window with an honest tail, computed from real completed payments
we have tracked, projected onto the currency's banking calendar.

This estimator is in BETA and still calibrating. Say so when you present a
number: call it an estimate or a typical window, never a commitment, and
never let a user plan an irreversible decision (a cutoff, a contractual
settlement date) on it without that caveat. The payload carries beta=true
while this holds.

Two modes:
\- Forward (default): "when will it land" — returns P50/P90/P95 arrival
  dates, sample size, confidence, competing non-arrival risk, delay-risk
  factors, and (where validated) the most likely correspondent route.
\- Reverse: pass arrive_by_date (YYYY-MM-DD) — returns the latest send
  date such that arrival by that day is likely ("send by Thursday to
  land by month-end").

INPUT DISCIPLINE (important):
\- Mid-flight payment: pass ONLY the uetr (from TrackingContext or
  track_payment). The server resolves the current status, currency and
  elapsed time deterministically from the tracking record. NEVER compute
  elapsed_business_days yourself.
\- Pre-trade question ("how long will a USD wire from X to Y take?"):
  pass currency + sender_bic/receiver_bic (8 or 11 chars, or bank names).
  current_status / elapsed_business_days are for this path only.

Reading the answer honestly (relay these to the user):
\- basis.n is the sample size and confidence reflects it; when confidence
  is "low", present the window as a rough range, never a promise.
\- basis.level says whose payments basis.n counts: `corridor` this bank
  pair, `sender_ccy` / `receiver_ccy` this sending / receiving bank in
  this currency, `currency` every bank in this currency, `global` every
  tracked payment in every currency. basis.currency is the PAYMENT's
  currency, not the pool's: a global answer is never "<currency>
  payments". basis.pool says it in words where it matters.
\- basis…

Input parameters:

- `amount`: Payment amount; it improves the delay-risk assessment. A plain number is fine: 50000 and "50,000.00" are both accepted.
- `api_key`: Your Ohmyfin API key (prod-...). Optional here: it can be sent instead as a KEY header or an Authorization: Bearer header. What the tool requires of the key is in its description.
- `arrive_by_date`: YYYY-MM-DD; switches to reverse send-by mode. You do not know today's date: a deadline stated as "the 20th" or "by month-end" must be resolved against the `today` block returned by bank_holidays / va…
- `currency`: 3-letter ISO 4217 currency. Needed without a uetr. With a uetr, leave it out: the tracking record's currency is used, and a currency you pass replaces it. Pass it with a uetr only when the answer's u…
- `current_status`: Status code such as ACSP, for the path without a uetr only.
- `elapsed_business_days`: Business days already in flight, for the path without a uetr only.
- `intermediary_bic`: Optional BIC of a known intermediary bank.
- `receiver_bic`: Receiving bank's BIC (8 or 11 characters) or bank name, for the pre-trade path.
- `receiver_country`: Optional ISO 3166-1 alpha-2 country code of the receiving bank.
- `sender_bic`: Sending bank's BIC (8 or 11 characters) or bank name, for the pre-trade path.
- `sender_country`: Optional ISO 3166-1 alpha-2 country code of the sending bank.
- `uetr`: UETR of a tracked payment, UUID v4 (e.g. "eb6305c8-0710-4e41-84ad-f58db3083e82"). Preferred for a payment already in flight; see INPUT DISCIPLINE in the description.

### `transfer_cost` (~2100 tokens)

Transfer Fee Estimate (Beta)

BETA. Estimate what a cross-border payment will COST, split by WHO
PAYS: the sending bank's published fee (the sender's side), what
correspondents deduct in transit and what the beneficiary's own bank
charges to credit it (the beneficiary's side), and what actually lands.

This estimator is in BETA. Present every number as a typical case and a
high case, never as a quote, and never let a user commit to a contractual
amount on it. The payload carries beta=true while this holds.

HOW TO READ THE ANSWER (relay these honestly):
\- `answered=false` means we REFUSED. The most common reason is that we
  hold no published tariff rule for the sending bank, in which case there
  is deliberately no total and no "recipient receives" figure. Say we do
  not know what that bank charges. Do NOT add up the parts yourself and
  present a total: treating the unknown fee as zero is the exact defect
  this tool was built to remove.
\- The correspondent fee is a RANGE (`p50` typical, `p90` high case), not a
  point. The spread is real: SWIFT tracking never reveals whether a
  payment was sent OUR, SHA or BEN, so a single cohort mixes all three.
\- THREE FEES, THREE DIFFERENT PAYERS, AND THEY ARE NOT INTERCHANGEABLE.
  \`sending_fee` is billed to the SENDER by their own bank.
  \`correspondent_fee` comes out of the payment in transit, so the
  BENEFICIARY bears it. `beneficiary_fee` is what the RECEIVING bank
  charges its own customer to credit the payment, so the beneficiary bears
  that too - and it is frequently the largest of the three (measured
  2026-08-22 on one live corridor: 35.26 USD of sender-side cost against a
  245.68 USD beneficiary bank fee). Never quote one of them as "the cost",
  and never call the beneficiary bank's fee a correspondent charge.
  \`total` is the sending fee plus the transit deduction; `total_both_sides`
  adds the beneficiary bank's fee and is the all-in figure.
\- WHERE EACH NUMBER COMES FROM. The correspondent fee is OBSERVED, from
  payments we have trac…

Input parameters:

- `amount` (number, required): Transfer amount in `currency`, greater than zero.
- `api_key`: Your Ohmyfin API key (prod-...). Optional here: it can be sent instead as a KEY header or an Authorization: Bearer header. What the tool requires of the key is in its description.
- `bank_swift` (string, required): Sending bank's BIC, 8 or 11 characters.
- `beneficiary_bic`: Receiving bank's BIC (8 or 11 characters); needed for a total.
- `beneficiary_segment`: Who is being PAID: individual | business | financial_institution. Omitted, it mirrors customer_segment.
- `channel`: Sending channel: online | branch | mobile_app | any.
- `charge_type` (string): SHA (default), OUR or BEN. Ask the user rather than guessing.
- `currency` (string, required): 3-letter ISO 4217 transfer currency.
- `customer_segment`: Who is SENDING: individual | business | financial_institution.
- `customer_sub_segment`: The sender's tier at their bank: standard | premium | private_banking | vip.

### `mcp_register` (~209 tokens)

Register for an API Key

Register for an Ohmyfin API key to use paid tools.

Creates an account and sends a 6-digit verification code to your
email. After receiving the code, call mcp_verify to complete
registration and get your API key.

By setting accept_terms to true, you confirm acceptance of the
Ohmyfin Terms & Conditions (https://ohmyfin.ai/terms) on behalf
of your operator, including the API/MCP access terms (Section 3A),
sanctions screening terms (Section 3B), and financial data
disclaimer (Section 3C).

Examples:
  mcp_register("agent@example.com", "Acme Corp", true)

Input parameters:

- `accept_terms` (boolean, required): Must be true. Confirms acceptance of the Ohmyfin Terms & Conditions at https://ohmyfin.ai/terms.
- `email` (string, required): Your email address. The verification code is sent to it.
- `organization_name` (string, required): Your company or project name.

### `mcp_verify` (~111 tokens)

Verify Email and Activate API Key

Verify your email and receive your API key.

After calling mcp_register, check your email for the 6-digit code
and pass it here. On success, returns your production and test
API keys. You must subscribe at ohmyfin.ai/subscription to
activate paid tools.

Examples:
  mcp_verify("agent@example.com", "123456")

Input parameters:

- `code` (string, required): The 6-digit verification code from that email.
- `email` (string, required): The email address you registered with.

### `sanctions_screen` (~1530 tokens)

Sanctions and Watchlist Screening

Screen a name against global sanctions and watchlists.

A crypto wallet address is checked as an address, never as a name.

Checks the name against 300+ sanctions, designation and watchlists
worldwide, including US OFAC (SDN and non-SDN), EU, UK OFSI, Canada,
Switzerland, Australia, New Zealand, Japan, Israel and national lists.
Returns matching entities with similarity scores. The response says how
many lists were actually searched (lists_searched); report THAT, and do not
present a fixed per-jurisdiction table of "clear" rows, which asserts a
per-list result the screen does not return and understates the coverage.

For a company or an individual the screen covers every list, including
adverse media, PEP and debarment registers. For a BANK or other financial
institution it returns sanctions DESIGNATIONS only: a warning-list entry
naming a bank is usually a clone-firm alert about fraudsters impersonating
it, and the feed carries nothing that tells the two apart.

When the name resolves in our bank directory, each designation is also
cross-referenced against that institution's record (country, entity type,
and the name or ALIAS that earned the fuzzy score) and contradicted rows are
removed. ALWAYS read the `verification` block, which is on every response:
\`applied: false` means nothing was cross-referenced and the rows are raw
feed output — either the name is not in our bank directory, or the subject
is a company or individual, which has no directory record to check against.
Never report an `applied: false` result as verified, and never report an
empty one as verified-clear. Screening a bank by BIC, or calling
swift_lookup, gets a verified answer.

A row surviving that cross-reference is NOT the same as a row the
cross-reference supported. Each verified row carries `adjudication`:
\`corroborated` means the check backed it and it is a designation against
this institution; `not_corroborated` means it survived the false-positive
floor but nothing tied it to this institu…

Input parameters:

- `api_key`: Your Ohmyfin API key (prod-...). Optional here: it can be sent instead as a KEY header or an Authorization: Bearer header. What the tool requires of the key is in its description.
- `name` (string, required): The person or entity name to screen.
- `subject_type` (string): What is being screened: "bank" for a financial institution, "party" for a company or individual, or "auto" (default). A name the bank directory resolves is treated as a financial institution whatever…
- `threshold` (integer): Minimum match score, 0-100 (default 85). Values above 95 are treated as 95.

### `crypto_wallet_screen` (~734 tokens)

Crypto Wallet Check

Check a crypto wallet address: who owns it, which lists name it, and where its funds came from.

A crypto wallet address is checked as an address, never as a name. Pass
the address as written; the chain is detected when omitted.

The answer is the verdict block: `state`, `tier` (block, high, review,
monitor or clear), `score` (0 to 10), `headline`, `main_reason` (a
sentence and its data; `data.kind` is `state_order` when an Israeli
NBCTF seizure or forfeiture order names the address, which is not a
sanctions listing), `owner` with its `evidence` (official_list,
own_publication or bought_label), `list_hits`, `checked` (the chains,
assets, hops and lists covered, and when), `recommended_action`,
\`check_id`, `report_url` (the wallet page) and `report_price` (how opening
the full report would be paid).

Each `list_hits` item and `owner` carry `listed_at` (the date the list
names the entry since), `list_ref` (the list's own id of the entry, e.g.
the OFAC uid) and `entry_url` (that entry's official page, e.g. OFAC's
Sanctions List Search). When `entry_url` is null, `source_url` is the
list's own file or notice: say so, never call it the entry's page.

\`state`:
\- `finished`: the check ran to the end; `checked` says what it covered.
\- `pending`: the check is still running (`running: true`). It is not
  finished; collect it with crypto_wallet_result and the `check_id`.
\- `incomplete`: not finished. Report it as not finished, never as
  nothing found.
\- `unavailable`: no answer could be obtained just now.
\- `no_activity`: no transactions were found for the address on the
  chains checked; it may be mistyped, on another chain, or never used.
\- `lists_only`: the chain is covered by sanctions lists only, with no
  tracing of funds.
\- `invalid`: the address fails its checksum, so it was not checked.

Say what was found and what `checked` covered. The full report is
crypto_wallet_report. `paths_found` is how many paths of funds it holds:
with 0 it states what was read (`checked.r…

Input parameters:

- `address` (string, required): The crypto wallet address to check, exactly as written (for example a TRON address starting with T, an Ethereum address starting with 0x, or a Bitcoin address).
- `api_key`: Your Ohmyfin API key (prod-...). Optional here: it can be sent instead as a KEY header or an Authorization: Bearer header. What the tool requires of the key is in its description.
- `chain`: Optional chain, e.g. "tron", "ethereum", "bitcoin", "litecoin". Detected from the address when omitted.
- `customer_ref`: Optional reference of your own (a customer or case id), kept with the check and returned with it.

### `crypto_wallet_result` (~214 tokens)

Crypto Wallet Check Result

Read a crypto wallet check again, or collect one that was still running.

A crypto wallet address is checked as an address, never as a name. This
reads the check crypto_wallet_screen started, by its `check_id`, and
answers the same verdict block. Reading it again starts nothing new.

\`pending` (`running: true`) means it is still running: ask again in a
minute. `pending` and `incomplete` are not finished, never nothing
found. The meaning of every field is in crypto_wallet_screen.

Examples:
  crypto_wallet_result("01JD8Q7T6XK3M5N9P2R4S6V8W0")

Input parameters:

- `api_key`: Your Ohmyfin API key (prod-...). Optional here: it can be sent instead as a KEY header or an Authorization: Bearer header. What the tool requires of the key is in its description.
- `check_id` (string, required): The check_id returned by crypto_wallet_screen.

### `crypto_wallet_report` (~423 tokens)

Crypto Wallet Full Report

Open the full report of a crypto wallet check: why it got its verdict, and the paths of funds behind it.

A crypto wallet address is checked as an address, never as a name. The
report belongs to a check crypto_wallet_screen made (`check_id`) and
answers `report` (`why`, `paths`, `decision`, `score_lines`, `read`,
\`paths_note`), `pdf_url` and the `wallet` verdict block.

\`report.paths` is empty when nothing that was read came from or went to
a listed or risky source within 2 hops; `report.paths_note` then says so
with what was read (`report.read`: transfers, period, USD in and out).
An empty `paths` means "no transfers" only when `report.read.transfers`
is 0.

Opening a report is paid from the account's plan or its credits. When
opening would spend a credit and `confirm` is not true, nothing is
opened or spent: the answer carries `needs_confirmation: true`, the
\`price` and its `price_line`. Tell the user the price, and call again
with confirm=true only once they agree. A report already opened is read
again at no charge.

Examples:
  crypto_wallet_report("01JD8Q7T6XK3M5N9P2R4S6V8W0")
  crypto_wallet_report("01JD8Q7T6XK3M5N9P2R4S6V8W0", confirm=True)

Input parameters:

- `api_key`: Your Ohmyfin API key (prod-...). Optional here: it can be sent instead as a KEY header or an Authorization: Bearer header. What the tool requires of the key is in its description.
- `check_id` (string, required): The check_id returned by crypto_wallet_screen.
- `confirm` (boolean): Set true only after the user has agreed to the price this tool stated for opening the report. Default false: nothing is spent.

### `eccn_lookup` (~176 tokens)

ECCN Lookup

Look up an Export Control Classification Number (ECCN).

Pure reference tool — returns classification details, controlled
jurisdictions, and license requirements for the given ECCN.

ECCNs are alphanumeric codes (e.g. "5A001") used under export control
regimes (US EAR, EU Dual-Use Regulation, Wassenaar Arrangement) to
classify items that may require an export license.

Examples:
  eccn_lookup("5A001")   # Telecommunications security equipment
  eccn_lookup("3A001")   # Electronic components
  eccn_lookup("1C351")   # Human pathogens, zoonoses, toxins

Input parameters:

- `eccn` (string, required): Export Control Classification Number, e.g. "5A001", "3A001", "1C351". Case-insensitive.

### `country_export_controls` (~304 tokens)

Country Export-Control Restrictions

Look up export control restrictions for a specific country.

Returns embargo status, sanctioned programs, control reasons, and
restriction details across jurisdictions (US EAR, EU, UN, etc.)
for the given country. Response also includes a payment_jurisdiction_note
explaining when each listed restriction actually applies to a payment
(US controls only bind when there's a US nexus, etc.).

IMPORTANT: Each jurisdiction's controls only bind a payment when the
payment has a nexus to that jurisdiction. Use the jurisdiction filter
when you know the payment's actual jurisdictional touchpoints (sender
country, clearing currency, intermediary banks). For a CHF/EUR payment
with no US bank in the chain, US export controls are informational only
— do NOT cite them as compliance blockers without confirming a US nexus.

Examples:
  country_export_controls("RU")          # Russia — heavily embargoed
  country_export_controls("CN")          # China — partial restrictions
  country_export_controls("DE")          # Germany — minimal controls
  country_export_controls("RU", "US")    # Russia, US jurisdiction only

Use case: 'What export restrictions apply to shipping to Russia?'

Input parameters:

- `country_code` (string, required): ISO 3166-1 alpha-2 country code, e.g. "RU", "CN", "DE".
- `jurisdiction` (string): Optional filter by jurisdiction, e.g. "US", "EU". Omit it for every jurisdiction.

### `export_controls_screen` (~599 tokens)

Export-Control Goods Screening

Screen goods for export-control restrictions to a destination country.

Combines the goods classification with the destination's restriction status
and returns whether a license is required, the risk level, applicable
license policies (e.g. presumption of denial), control reasons (NS, MT, NP,
CB, AT), and proliferation/dual-use flags. Identify the goods by ANY of:
ECCN, HS code, or a free-text description (English or Russian).

IMPORTANT — jurisdiction nexus: each jurisdiction's controls only bind a
payment/shipment when there is a nexus to that jurisdiction (US EAR binds
US persons, USD-clearing, and US-origin items; EU/UK/JP bind their persons,
currencies, and origin). Use jurisdiction="ALL" for a comprehensive
multi-jurisdiction view, or pick the one matching the actual touchpoints.

IMPORTANT, prefer eccn or hs_code: goods_description is a fallback: the
classifier matches it lexically, so a vague description still returns one
specific HS code and it is usually the wrong one ("industrial machinery"
returns bakery and pasta machinery). When you pass a description only, the
result carries classification_basis and classification_confidence_note;
read them, never quote the inferred code back to the user as their HS code
or ECCN, and ask for the code on their invoice or export declaration. The
destination findings (embargo, transshipment risk, screening duties) are
NOT affected by that doubt, so report them normally.

Provide at least one of eccn / hs_code / goods_description.

Examples:
  export_controls_screen("RU", eccn="3A001")                       # electronics → Russia
  export_controls_screen("CN", eccn="3A090")                       # advanced computing → China
  export_controls_screen("IR", goods_description="industrial valves")
  export_controls_screen("RU", goods_description="drone", jurisdiction="ALL")
  export_controls_screen("DE", hs_code="854231")                   # → Germany (allied)

Use case: 'Can we ship integrated circuits to Russia?'

Input parameters:

- `destination_country` (string, required): Destination country, ISO 3166-1 alpha-2 country code (e.g. "RU", "CN").
- `eccn` (string): Export Control Classification Number, e.g. "3A001". Give at least one of eccn, hs_code, goods_description.
- `goods_description` (string): Free-text goods description, English or Russian. A fallback for when no eccn or hs_code is known; see the description.
- `hs_code` (string): Harmonized System code, 4-8 digits (e.g. "854231"). Give at least one of eccn, hs_code, goods_description.
- `jurisdiction` (string): "US" (default), "EU", "UK", "JP", "ITAR", or "ALL".

### `hs_code_lookup` (~301 tokens)

HS Code Lookup

Reverse-lookup an HS code → mapped export-control classifications (ECCNs).

For customs brokers / shippers who have an HS (Harmonized System) code and
need to know which export-control classifications may apply. Returns the
mapped ECCNs with confidence levels, control reasons, sensitivity, and the
governing international regime (Wassenaar, MTCR, NSG, etc.).

A 4-digit HS heading is accepted, but mappings are richest at the 6-digit
subheading level (e.g. "854231" rather than "8542"). An empty mapping list
means no export-control mapping is on file for that code — it is NOT a
guarantee the goods are uncontrolled; confirm with goods_classify or a
formal classification.

Examples:
  hs_code_lookup("854231")          # semiconductors → 3A001 / 3A090 ...
  hs_code_lookup("841112")          # turbojet engines → 9A001 ...
  hs_code_lookup("854231", "US")    # US mappings only

Use case: 'What export controls might apply to HS code 854231?'

Input parameters:

- `hs_code` (string, required): HS code, 4-6 digits (e.g. "854231", "8411"). Dots and spaces are fine.
- `jurisdiction` (string): Optional filter: "US", "EU", "UK" or "JP".

### `goods_classify` (~401 tokens)

Goods Classification

Classify goods for export control from a description (or HS code).

Bilingual (English / Russian, auto-detected) goods classifier. Returns the
best-matching HS code (with EN+RU descriptions), related ECCNs, control
reasons (NS, MT, NP, CB, AT...), an export-control level (high/medium/low/
none), a confidence score, and alternative matches for review.

This is destination-agnostic — it identifies WHAT the goods are and whether
they are controlled in principle. To get the license decision FOR A SPECIFIC
destination, pass the result into export_controls_screen.

IMPORTANT, the matcher is lexical, and confidence scores the strength of
the string match, not the correctness of the classification: "equipment"
returns semiconductor manufacturing equipment at confidence 1.0. Treat the
code as a suggestion for narrowing the question. When no hs_code was
supplied the result carries classification_basis and
classification_confidence_note; read them before quoting any code, and ask
the user for the HS code or ECCN on their shipping documentation.

Examples:
  goods_classify("uranium centrifuge")                 # → HS 840120, ECCN 0B001
  goods_classify("центрифуга для обогащения урана")    # Russian query, same result
  goods_classify("semiconductor manufacturing equipment")
  goods_classify("", hs_code="840120")                 # direct HS lookup

Use case: 'Is a semiconductor lithography machine export-controlled?'

Input parameters:

- `description` (string, required): Goods description, at least 2 characters (e.g. "uranium centrifuge", "центрифуга для урана").
- `hs_code` (string): Optional known HS code (4 or 6 digits) for a direct lookup.
- `language` (string): Optional hint: "en" or "ru" (auto-detected if omitted).

### `federal_register_changes` (~248 tokens)

Federal Register Export and Sanctions Changes

Get recent US regulatory changes from BIS and OFAC.

Returns Federal Register publications including entity list updates,
rule changes, country policy shifts, and new sanctions programs.

Examples:
  federal_register_changes()                          # Last 30 days, all
  federal_register_changes(agency="OFAC", days=7)     # OFAC changes this week
  federal_register_changes(category="entity_list", severity="critical")

Use case: 'Any new entity list additions affecting China?'

Input parameters:

- `agency` (string): Optional: "BIS" (Bureau of Industry and Security) or "OFAC" (Office of Foreign Assets Control). Omit it for both.
- `category` (string): Optional: "entity_list", "rule_change", "country_policy" or "sanctions". Omit it for every category.
- `days` (integer): Days to look back, 1-365 (default 30). A value outside the range is refused.
- `limit` (integer): Maximum number of changes to return (default 50).
- `severity` (string): Optional: "critical", "high", "medium" or "low". Omit it for every level.

### `track_payment` (~1595 tokens)

Track a Cross-Border Payment

Track a SWIFT payment by UETR or reference number.

Basic SWIFT payment tracking enriched by data from certain banks in
the correspondent chain. Returns the overall payment status and,
when available, per-bank details showing which banks reported
information about this payment.

IMPORTANT — every trace needs four things:
  amount, currency, date, and an identifier (uetr, or reference when
  there is no UETR). amount, currency and date are required
  parameters, on the UETR path too: there is no UETR-only lookup, so
  never tell the user the UETR alone is enough to run one. Ask for
  whatever is missing before calling, and never guess a value.

IMPORTANT — UETR vs Reference:
  The UETR (Unique End-to-End Transaction Reference) is a UUID
  assigned to every SWIFT gpi payment. Tracking by UETR succeeds
  \~80% of the time. Tracking by reference number alone succeeds
  less than 1% of the time because most banks only index by UETR.

  → Always provide the UETR if available.
  → The reference number is Field 20 of the MT103 (or the
    equivalent <InstrId>/<EndToEndId> in pacs.008). It is the
    sender's transaction reference. Still valuable — provide it
    alongside the UETR when you have both.

WHEN THE USER HAS ONLY A REFERENCE AND NO UETR
("how do I find / trace my payment?", "I have a reference number
but no UETR, where is it?"):
  This is exactly the scenario this tool can attempt — do NOT answer
  from general knowledge. A reference-based trace cannot be run from
  the reference alone; you MUST first collect three things from the user:
    1. amount   — the exact amount as sent
    2. currency — ISO 4217 (e.g. "USD")
    3. date     — the send date (within the last 90 days)
  Then call track_payment(reference=..., amount=..., currency=...,
  date=...). State the expectation up front: reference-only tracing
  succeeds less than 1% of the time.
  In parallel, tell the user how to recover the UETR for a reliable
  (~80%) trace: ask the SENDING bank for the MT103 co…

Input parameters:

- `amount` (number, required): Transaction amount as sent (e.g. 15000.00). Must match the original payment amount: even a small difference may stop tracking from finding the payment, so ask the user for the exact figure rather tha…
- `api_key`: Your Ohmyfin API key (prod-...). Optional here: it can be sent instead as a KEY header or an Authorization: Bearer header. What the tool requires of the key is in its description.
- `currency` (string, required): ISO 4217 code of the currency the payment was SENT in (e.g. "USD", "EUR", "GBP"). Ask if you do not know it; do not assume the sender's or the beneficiary's home currency.
- `date` (string, required): Transaction date. Preferred format YYYY-MM-DD (ISO 8601); DD.MM.YYYY and DD-MM-YYYY are also accepted, slash-separated dates are not. Must be within the last 90 days.
- `reference`: Sender's bank reference number (MT103 field 20 / pacs.008 InstrId). Useful beside the UETR for cross-referencing, but alone it rarely produces results. Required only if uetr is not provided.
- `uetr`: UETR, UUID v4 (e.g. "eb6305c8-0710-4e41-84ad-f58db3083e82"). Strongly recommended: tracking without a UETR rarely returns results. It is the Unique End-to-End Transaction Reference every gpi payment…

### `tracking_history` (~533 tokens)

Payment Tracking History

Show how a SWIFT payment's tracking results changed over time.

Returns the DISTINCT tracking results recorded for a payment (by UETR or
reference), deduplicated so ten identical re-tracks collapse to one entry
while any change — a new last-update, a status change, or new bank data —
appears as its own entry. Each entry includes what was ENTERED when the
search was run (amount, currency, date) alongside the banks that reported
data and their confirmed amount / value date.

WHEN TO USE THIS:
  \- The user says the page shows different data than you see, or asks why a
    bank line (e.g. JP Morgan) "disappeared" or a value date differs.
  \- You need to reconcile an amount or date discrepancy. JP Morgan returns
    its line only when the entered date and amount are close to its own
    record (seen: value dates up to 3 days apart, amounts mostly within 1%),
    so a search run with a wrong date or amount can silently drop its line.
    When it does answer, `amount_exact_match` is false if its value date OR
    its amount differs from what was entered, despite the name, and
    `amount_exact_match_detail` names which. Comparing entries here — same
    UETR, different entered dates or amounts, different bank data — is how
    you spot which entry was the problem.
  \- Before concluding "the record was consolidated" or "the bank stopped
    reporting", check the history: the earlier result you're being asked
    about is usually still here, under a different entered amount.

Each bank entry's `source` names the tracking SOURCE that reported it (e.g.
"Standard Chartered"), not the bank at a step of the payment; track_payment
names the same data by the bank at each step, so the two names differ.

Only results for the current user (plus system tracks with no owner) are
returned; other users' searches of the same UETR are never shown.

Requires an API key with an active FI subscription.

Input parameters:

- `api_key`: Your Ohmyfin API key (prod-...). Optional here: it can be sent instead as a KEY header or an Authorization: Bearer header. What the tool requires of the key is in its description.
- `reference`: Sender's reference (MT103 field 20), used when there is no UETR.
- `uetr`: UETR (UUID v4) of the payment. Strongly preferred.

### `my_tracked_payments` (~287 tokens)

My Tracked Payments

List the payments the signed-in account has tracked, newest first.

One row per payment tracked in the last 90 days, at most 50 (`truncated`
is true when there are more): uetr, reference, amount, currency, status,
reason_code, sender_bic, receiver_bic, and last_tracked (ISO 8601, UTC).
Archived payments are not listed.

WHEN TO USE THIS:
  \- The user refers to a payment they tracked before ("my payment", "my
    last transfer", "the EUR one to Hamburg") and gives no UETR or
    reference. Call this BEFORE asking for the payment's details, and ask
    only for what it does not settle.

The rows are the calling account's own: other users' and other
organisations' searches are never included. status is the last recorded
gpi status, not a live one; call track_payment for the current status.

Requires a signed-in account: Ohm on ohmyfin.ai, or an API key that
belongs to one user (an organisation-wide key has no payments of its own).

Input parameters:

- `api_key`: Your Ohmyfin API key (prod-...). Optional here: it can be sent instead as a KEY header or an Authorization: Bearer header. What the tool requires of the key is in its description.

### `ssi_lookup` (~1225 tokens)

Settlement Instructions (SSI) Lookup

Look up correspondent banking / settlement instructions (SSI) for a bank.

Returns the correspondent banks (nostro accounts) that a given bank
uses to settle payments in a specific currency, including account
numbers (when available) and intermediary chains. Essential for
payment routing and pre-validation.

Each correspondent is annotated with a clearing_note indicating
whether it can clear the currency directly (located in a home
country for that currency) or needs its own correspondent.
If the note suggests a further lookup, call ssi_lookup on the
correspondent's SWIFT code to find the full clearing chain.

IMPORTANT — known data gaps to respect:
\- Account numbers may be empty for some/all correspondents. The
  response surfaces an `account_availability_note` in those cases.
  Do NOT invent account numbers. Use swift_lookup() to find the
  bank's own published correspondent banks page when accounts
  are missing.
\- WHICH CORRESPONDENT: read `correspondent_selection`, not the array order.
  It gives the COMPLETE set of BICs for each flow (customer MT103 vs
  interbank MT202) and for whether the correspondent clears the currency
  itself, each with a count. The correspondents are returned in STORAGE
  order, which is not a ranking. Naming a subset ("principally X and Y",
  "route via X") invents a preference this feed does not hold. Name every
  BIC in the matching set, or give its count: which one is used is the
  SENDING bank's choice among the ones it can already reach, not the
  beneficiary bank's, and not ours to guess from bank size or reputation.
  \`is_preferred` is `null` on almost every row because the flag is
  genuinely unrecorded (11 rows in the entire corpus carry it); where it IS
  set, `correspondent_selection.bank_flagged_preference` names it and you
  should lead with that.
\- `intermediaries` is `null` — not `[]` — when this correspondent's onward
  chain is not recorded, which is 98% of rows. `null` means NOT ESTABLISHED,
  never zero hops: do no…

Input parameters:

- `api_key`: Your Ohmyfin API key (prod-...). Optional here: it can be sent instead as a KEY header or an Authorization: Bearer header. What the tool requires of the key is in its description.
- `currency` (string, required): ISO 4217 currency code (e.g. "USD", "EUR", "GBP").
- `swift` (string, required): BIC of the bank, 8 or 11 characters (e.g. "DEUTDEFF").

### `banks_using_correspondent` (~364 tokens)

Banks Using a Correspondent

Reverse SSI lookup — find banks that use a given correspondent for a currency.

Given a correspondent BIC, currency, and origin country, returns the banks
in that country that have a declared nostro at the correspondent for that
currency. Inverse of ssi_lookup.

Returns only swift + name per bank — to retrieve the account number,
intermediary chain, or other SSI details for a specific bank from the
result list, call ssi_lookup(bank_swift, currency) on it.

Country and currency are required (not optional) — both bound the result
set and the query is rejected without them.

Requires an API key with an active PRO, VIP, or FI subscription.

Examples:
  banks_using_correspondent("IRVTUS3N", "USD", "AE")
  banks_using_correspondent("CITIUS33", "USD", "SA", name_prefix="AL")

Input parameters:

- `api_key`: Your Ohmyfin API key (prod-...). Optional here: it can be sent instead as a KEY header or an Authorization: Bearer header. What the tool requires of the key is in its description.
- `correspondent_swift` (string, required): BIC of the correspondent bank, 8 or 11 characters (e.g. "IRVTUS3N").
- `country` (string, required): ISO 3166-1 alpha-2 country code of the client banks (e.g. "AE").
- `currency` (string, required): ISO 4217 currency code (e.g. "USD").
- `name_prefix`: Optional prefix on the client bank's name (e.g. "AL").
- `page` (integer): Result page, 1-4 (default 1). Any other value is refused.

### `company_search_person` (~451 tokens)

Company Registry Search: Person (Experimental)

EXPERIMENTAL — Search company registries for a person's directorships, officer roles, and shareholdings.

Searches worldwide company registries to find where a person holds
director, officer, or shareholder positions. Every person and company
found is automatically screened against sanctions lists.

You MUST specify at least one jurisdiction. "ALL" is not supported.
Available jurisdictions: AM, AT, AU, BR, CA, CH, CZ, DE, DK, EE, FI,
FR, IE, IL, IS, LT, LV, NL, NO, PL, SG, UK, XX. Call
company_registries() for the live list — this one can go stale.

XX is GLEIF LEI, a GLOBAL registry rather than a country. Use it for
anyone connected to a company outside the national registries above.

A jurisdiction NOT on that list is dropped silently by the backend: you
get total_results 0 with status "completed" and no error. That means the
person was never searched for — it is NOT evidence they hold no roles.
Check `jurisdictions_not_searched` and `coverage_warning` in the response
before you report an empty result to the user.

Examples:
  company_search_person("John Smith", jurisdictions=["UK", "NO"])
  company_search_person("Jane Doe", jurisdictions=["DE"])

Input parameters:

- `api_key`: Your Ohmyfin API key (prod-...). Optional here: it can be sent instead as a KEY header or an Authorization: Bearer header. What the tool requires of the key is in its description.
- `include_inactive_roles` (boolean): Include resigned and ceased roles (default true).
- `include_sanctions_check` (boolean): Screen every person and company found against sanctions lists (default true).
- `jurisdictions` (array, required): Registry codes to search, at least one (e.g. ["UK", "NO"]). "ALL" is not supported. The UK registry is "UK", not "GB"; "XX" is GLEIF LEI (global). company_registries() returns the live list.
- `name` (string, required): Person name to search for.

### `company_search_company` (~542 tokens)

Company Registry Search: Company (Experimental)

EXPERIMENTAL — Search company registries for a company with its officers and shareholders.

Find company registrations across worldwide registries, including
directors, officers, and beneficial owners (PSC/shareholders).
Every entity found is automatically screened against sanctions lists.

You MUST specify at least one jurisdiction. "ALL" is not supported.
Available jurisdictions: AM, AT, AU, BR, CA, CH, CZ, DE, DK, EE, FI,
FR, IE, IL, IS, LT, LV, NL, NO, PL, SG, UK, XX. Call
company_registries() for the live list — this one can go stale.

XX is GLEIF LEI, a GLOBAL registry rather than a country. Reach for it
whenever the company sits outside the national registries above — a
supplier in Hong Kong, mainland China, the US or the UAE. Hits carry an
LEI, a registered address and a search.gleif.org URL the user can open.

A jurisdiction NOT on that list is dropped silently by the backend: you
get total_results 0 with status "completed" and no error. That means the
company was never searched for — it is NOT evidence that it is
unregistered or fake, and saying so to someone checking a counterparty
before wiring money is the most damaging thing this tool can do. Check
\`jurisdictions_not_searched` and `coverage_warning` in the response
before you report an empty result.

Examples:
  company_search_company("Equinor", jurisdictions=["NO"])
  company_search_company("Acme Corp", jurisdictions=["UK", "DE"], include_only_active=True)

Input parameters:

- `api_key`: Your Ohmyfin API key (prod-...). Optional here: it can be sent instead as a KEY header or an Authorization: Bearer header. What the tool requires of the key is in its description.
- `include_officers` (boolean): Include directors and officers (default true).
- `include_only_active` (boolean): Return active companies only (default false).
- `include_sanctions_check` (boolean): Screen every company and person found against sanctions lists (default true).
- `include_shareholders` (boolean): Include PSC / beneficial owners (default true).
- `jurisdictions` (array, required): Registry codes to search, at least one (e.g. ["UK"]). "ALL" is not supported. The UK registry is "UK", not "GB"; "XX" is GLEIF LEI (global). company_registries() returns the live list.
- `name` (string, required): Company name to search for.

### `company_search_result` (~135 tokens)

Company Search Result (Experimental)

EXPERIMENTAL — Retrieve cached company search results by search ID.

Every company_search_person and company_search_company call returns
a search_id. Use this tool to retrieve those results again without
re-running the search.

Examples:
  company_search_result("abc123-def456")

Input parameters:

- `api_key`: Your Ohmyfin API key (prod-...). Optional here: it can be sent instead as a KEY header or an Authorization: Bearer header. What the tool requires of the key is in its description.
- `search_id` (string, required): The search_id returned by a previous company_search_person or company_search_company call.

### `company_registries` (~142 tokens)

Available Company Registries (Experimental)

EXPERIMENTAL — List available company registries and supported jurisdictions.

Returns the list of company registries that can be searched,
along with the jurisdiction codes you can use in
company_search_person and company_search_company. This is the LIVE
list and outranks the codes named in those two tools' descriptions.

Any country code not returned here has no registry behind it: a search
naming it comes back empty and "completed", which does not mean the
company is unregistered. `XX` (GLEIF LEI) is global and is the fallback
for those jurisdictions.

No API key required.

Examples:
  company_registries()

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/ai-ohmyfin-invoice/mcp#diagnostics

## Score history

- 2026-11-21: 67
- 2026-11-20: 66
- 2026-11-19: 66
- 2026-11-18: 65
- 2026-11-17: 65
- 2026-11-16: 64
- 2026-11-15: 64
- 2026-11-14: 63
- 2026-11-13: 63
- 2026-11-12: 62
- 2026-11-11: 62
- 2026-11-10: 62
- 2026-11-09: 61
- 2026-11-08: 61
- 2026-11-07: 60
- 2026-11-06: 60

## Common questions

### What is the ai.ohmyfin/invoice MCP server?

ai.ohmyfin/invoice is an MCP server listed in the public MCP registry as ai.ohmyfin/invoice. Cross-border invoices for AI agents: parties screened, VAT ID checked, EN 16931 e-invoice in PDF. This page covers its hosted endpoint (https://mcp.ohmyfin.ai/mcp?from=registry-invoice).

### Is the ai.ohmyfin/invoice MCP server safe to use?

ai.ohmyfin/invoice scores 67 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the ai.ohmyfin/invoice MCP server expose?

ai.ohmyfin/invoice exposes 38 tools: swift_lookup, iban_validate, country_banking_rules, country_payment_codes, fx_rate, and 33 more. Their descriptions and schemas cost roughly 20,629 tokens of context every time the server is loaded.

### Does the ai.ohmyfin/invoice MCP server require authentication?

No. We connected to ai.ohmyfin/invoice without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the ai.ohmyfin/invoice MCP server still maintained?

ai.ohmyfin/invoice is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What did VerifyMCP test on the ai.ohmyfin/invoice MCP server?

VerifyMCP ran 12 checks on ai.ohmyfin/invoice, covering TLS certificate, HTTPS, HSTS header, DNSSEC and 8 more. One item could not be completed, a gap on our side rather than a finding about ai.ohmyfin/invoice: Authorization. Supply Chain Security and Provenance & Transparency do not apply to a hosted endpoint, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- Remote endpoint: https://mcp.ohmyfin.ai/mcp?from=registry-invoice
- Website: https://ohmyfin.ai/invoice/generator
- Changelog RSS feed: https://verifymcp.io/servers/ai-ohmyfin-invoice/mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/ai-ohmyfin-invoice/mcp/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/ai-ohmyfin-invoice/mcp.json
- HTML version of this page: https://verifymcp.io/servers/ai-ohmyfin-invoice/mcp
