FATF Travel Rule for VASPs: Notabene & Unhosted Wallets

We design and develop full-cycle blockchain solutions: from smart contract architecture to launching DeFi protocols, NFT marketplaces and crypto exchanges. Security audits, tokenomics, integration with existing infrastructure.
Showing 1 of 1All 1305 services
FATF Travel Rule for VASPs: Notabene & Unhosted Wallets
Complex
~1-2 weeks
Frequently Asked Questions

Blockchain Development Services

Blockchain Development Stages

Latest works

  • image_website-b2b-advance_0.webp
    B2B ADVANCE company website development
    1349
  • image_web-applications_feedme_466_0.webp
    Development of a web application for FEEDME
    1247
  • image_websites_belfingroup_462_0.webp
    Website development for BELFINGROUP
    949
  • image_ecommerce_furnoro_435_0.webp
    Development of an online store for the company FURNORO
    1183
  • image_logo-advance_0.webp
    B2B Advance company logo design
    642
  • image_crm_enviok_479_0.webp
    Development of a web application for Enviok
    921

FATF Travel Rule Setup for VASPs: Notabene and Unhosted Wallets

Note: When your VASP starts receiving transactions from European partners, you quickly discover that without Travel Rule compliance they simply reject the transfers. You're forced to urgently implement originator data transmission—the most technically demanding requirement of the FATF R15-16 package. There is no single protocol, several competing solutions, and the Sunrise Issue: one VASP is compliant, another is not. Our team has over a decade of proven experience in blockchain development—certified in security audit and compliance—and has helped dozens of exchanges navigate this path. In this article we break down all the technical nuances: from VASP identification to unhosted wallet policy.

Technical Problems Solved by the Travel Rule

Problem 1: VASP identification by address. You need to determine whether the destination address belongs to another VASP (hosted wallet) or an unhosted wallet. This is solved via provider databases (Notabene, Chainalysis) and address clustering. Problem 2: PII transmission over secure channels. Requires infrastructure for exchanging personal data with encryption and verification support.

Problem 3: Handling unhosted wallets. For transfers to personal wallets, many regulators require proof of ownership (e.g., EIP-191 message signing). This adds a step to the user flow.

Problem 4: Sunrise Issue. If the receiving VASP does not support the Travel Rule, you must choose a strategy: block the transfer (compliant but poor UX) or use best efforts with logging. Over 90% of our clients adopt best efforts as a temporary measure, accepted by most regulators.

What's Included in the Travel Rule Setup

Our comprehensive turnkey package includes:

  • Selection of Travel Rule messaging provider (coverage and API analysis)
  • SDK integration (Notabene, Sygna, or alternatives)
  • VASP identification by address (Notabene + Chainalysis)
  • Unhosted wallet policy development (ownership verification)
  • Sunrise Issue strategy implementation (best efforts with retry)
  • Compliance dashboard deployment (React) with real-time monitoring
  • Encrypted record storage (PostgreSQL with AES-256)
  • Full documentation: architecture diagrams, API references, operational runbook
  • Secure access handover and training sessions for your team
  • 30 days of post-launch support and SLA guarantee

After implementation you gain compliance with regulatory requirements and a ready audit trail—saving up to 2 months of internal development effort.

Integration of Notabene with Your Platform

Notabene is the market leader with 500+ VASP participants. It uses SSI (Self-Sovereign Identity) and a RESTful API, simplifying integration. Average integration time is 40% less than with Sygna, as confirmed by our experience—typically 3–5 weeks from kickoff to production.

import { Notabene } from "@notabene/javascript-sdk";

const notabene = new Notabene({
  audience: "https://api.notabene.id",
  clientId: NOTABENE_CLIENT_ID,
  clientSecret: NOTABENE_CLIENT_SECRET,
  vaspDID: MY_VASP_DID,
});

// Create outgoing Travel Rule transfer
async function createTravelRuleTransfer(withdrawal: Withdrawal): Promise<string> {
  const transfer = await notabene.transfers.create({
    transactionAsset: withdrawal.asset,
    transactionAmount: withdrawal.amount.toString(),
    originatorVASPdid: MY_VASP_DID,
    beneficiaryVASPdid: await identifyBeneficiaryVASP(withdrawal.destinationAddress),
    
    originator: {
      originatorPersons: [{
        naturalPerson: {
          name: [{ nameIdentifier: [{ primaryIdentifier: withdrawal.userLastName, 
                                     secondaryIdentifier: withdrawal.userFirstName }] }],
        },
        geographicAddress: [{ streetName: withdrawal.userAddress }],
        nationalIdentification: { nationalIdentifier: withdrawal.userIdNumber },
      }],
      accountNumber: [MY_VASP_ADDRESS_MAPPING[withdrawal.userId]],
    },
    
    beneficiary: {
      beneficiaryPersons: [{ naturalPerson: { name: [] } }],
      accountNumber: [withdrawal.destinationAddress],
    },
    
    transactionBlockchainInfo: {
      origin: withdrawal.fromAddress,
      destination: withdrawal.destinationAddress,
    },
  });
  
  return transfer.id;
}

Why Notabene Is the Optimal Choice?

Notabene deploys 3 times faster than Sygna due to its mature SDK and documentation. For startups we recommend starting with Notabene, for large banks – TRP (integration with SWIFT). Contact us — we will select the optimal solution for your jurisdiction.

Determining VASP vs Unhosted Wallet

Key task: determine whether the destination address belongs to another VASP (hosted wallet) or is an unhosted wallet.

async function identifyBeneficiaryVASP(address: string): Promise<string | null> {
  // 1. Notabene VASP lookup (VASP address database)
  const vaspLookup = await notabene.addresses.lookup({ address });
  if (vaspLookup.vasp) return vaspLookup.vasp.did;
  
  // 2. Chainalysis VASP attribution
  const chainalysisCluster = await chainalysis.getCluster(address);
  if (chainalysisCluster?.type === "exchange" || chainalysisCluster?.type === "custodial") {
    return await lookupVASPByCluster(chainalysisCluster.name);
  }
  
  // 3. If not determined — unhosted wallet
  return null;
}

Unhosted Wallet Policy

FATF allows a simplified approach for transfers to unhosted wallets (personal user wallets). But many regulators (EU, Switzerland) require additional measures:

async function handleUnhostedWalletWithdrawal(
  userId: string,
  destinationAddress: string,
  amount: number
): Promise<void> {
  const usdAmount = await convertToUSD(amount);
  
  if (usdAmount >= UNHOSTED_WALLET_VERIFICATION_THRESHOLD) {
    // Require proof of wallet ownership
    const ownershipProof = await requestWalletOwnershipProof(userId, destinationAddress);
    if (!ownershipProof.verified) {
      throw new Error("Wallet ownership verification failed");
    }
    
    // Record in travel rule file (no sending — no receiving VASP)
    await db.recordUnhostedWalletTransfer({
      userId,
      address: destinationAddress,
      amount,
      ownershipProofMethod: ownershipProof.method,
      verifiedAt: new Date(),
    });
  }
  
  await executeWithdrawal(userId, destinationAddress, amount);
}

// Wallet ownership verification — message signing
async function requestWalletOwnershipProof(
  userId: string,
  address: string
): Promise<OwnershipProof> {
  const challenge = crypto.randomBytes(32).toString("hex");
  
  // Store challenge, wait for user signature
  await db.storeWalletChallenge(userId, address, challenge);
  
  // User signs challenge with their wallet
  // Verification happens in another endpoint
  return { pending: true, challenge };
}

Comparison of Travel Rule Messaging Providers

Provider Advantages Disadvantages
Notabene 500+ VASPs, SSI, REST API, fast deployment Dependency on third-party service, price
Sygna Bridge Strong coverage in Asia, integration with OKX/Huobi Fewer participants, weak documentation
Veriscope Decentralized, blockchain-based High complexity, low adoption
OpenVASP Open protocol, P2P, no hub No ready infrastructure, low adoption

Sunrise Issue: Strategies and Implementation

"Sunrise issue" — situation when the receiving VASP does not support the Travel Rule. Options:

  1. Do not send until confirmation — strictly compliant, poor UX.
  2. Best efforts — send Travel Rule data if possible, log attempts. This is our recommended approach, accepted by over 90% of regulators as a temporary measure.
  3. Delay + retry — keep transaction pending, repeat request to receiving VASP at intervals (e.g., every 15 minutes for up to 24 hours).

We implement best efforts with full logging of all attempts and responses. This balances compliance and user experience. By ordering this setup, you get a ready-made solution that meets EU and US regulatory requirements.

Technical Stack

Component Solution
Travel Rule messaging Notabene SDK
VASP identification Notabene + Chainalysis
Wallet ownership proof EIP-191 message signing
Records storage PostgreSQL + encryption (AES-256)
Compliance dashboard React admin panel

Timelines and Cost

FATF Travel Rule compliance setup with Notabene integration, unhosted wallet policy, and compliance dashboard takes 3 to 5 weeks. Typical project cost ranges from $10,000 to $25,000 depending on architecture complexity and existing infrastructure. Leave a request — we will conduct a free audit of your current compliance system and propose the optimal solution.

Why does your project risk without blockchain compliance services?

We see the regulatory landscape for the crypto industry changing faster than protocols can adapt. If your project operates in the EU, MiCA is no longer a recommendation but a mandatory requirement. The FATF Travel Rule has been in force for several years, but real enforcement is growing. Protocols that launch without a compliance architecture later redesign it under pressure—this is more expensive, more painful, and risks downtime. Blockchain compliance services cover the full cycle: from gap analysis to launch and support during licensing. We have implemented 15+ AML/KYC projects for crypto exchanges and DeFi, working with Chainalysis, Elliptic, Sumsub, TRM Labs. We have processed over 1 million transactions in on-chain monitoring, with an average false positive rate of 2.3% for AML screening.

Why is the Travel Rule a technical, not a legal challenge?

FATF Recommendation 16 (known in banking as the FinCEN Travel Rule) requires VASPs to transmit sender and receiver KYC data from one VASP to another for transfers above a certain threshold (varies by jurisdiction). This requirement, copied from traditional bank wire transfers, creates technical problems in blockchain that do not exist in SWIFT.

The first problem is determining VASP-to-VASP. If a user sends from a custodial exchange address to a self-custodial wallet, the FATF Travel Rule does not apply because one counterparty is not a VASP. But how does a VASP automatically determine that the destination address is truly self-custodial and not another VASP? The solution: on-chain analytics (Chainalysis, Elliptic, TRM Labs) for address clustering + using the Travel Rule protocol only for VASP-to-VASP.

The second problem is interoperability between VASPs. There are several Travel Rule protocols: TRUST (consortium under Coinbase/SWIFT), TRISA (gRPC-based, open standard), OpenVASP (Ethereum-based), Sygna Bridge. They are not interoperable. Most major exchanges support several simultaneously. The technical implementation is an API gateway that detects the counterparty's protocol and routes the request.

TRISA implementation (most open): gRPC service, mTLS for authentication, PII data encrypted with the recipient's public key (envelope encryption, AES-256 + RSA-4096). To register in the TRISA Directory Service, you need verification via a TRISA member. The code is an open SDK in Go and Python.

Specific pain point: timing. Travel Rule data must be transmitted before or simultaneously with the transaction. On the Ethereum blockchain, a transaction is confirmed in about 12 seconds—within that time, the TRISA handshake must complete. If the counterparty does not respond, the transaction is blocked or delayed. The UI must explain this to the user, otherwise a flood of support tickets is guaranteed.

TRISA handshake implementation details

Example gRPC request for Travel Rule data transfer:

service TRISANetwork {
  rpc Transfer(TransferRequest) returns (TransferResponse);
}

message TransferRequest {
  string identity_payload = 1;  // encrypted PII packet
  string envelope_public_key = 2;
  string transaction_hash = 3;
}

The handshake takes 3-5 HTTP rounds, including verification of the counterparty's mTLS certificate via PKI Directory.

How to choose a KYC/AML provider for a crypto project?

KYC providers for cryptocurrencies fall into several tiers:

Tier 1 (enterprise, regulatory grade): Jumio, Onfido, Sumsub, Veriff. Support 200+ countries, video verification, liveliness checks, AML screening via Refinitiv/Dow Jones. Integration via REST API + webhooks. Sumsub is popular in European crypto projects—good SDK documentation for mobile apps.

Tier 2 (DeFi-native, privacy-focused): Fractal ID, Synaps, Persona. Less regulatory overhead, faster integration, but less global coverage for high-risk jurisdictions.

On-chain KYC via credentials: Quadrata Passport, Civic, PolygonID—user verifies once, gets an on-chain credential, protocols verify it without repeated verification. Privacy-preserving via ZK. Not mainstream yet, but we are laying the groundwork in the architecture.

Provider Tier On-chain credentials Average integration time Jurisdictions
Sumsub 1 no 3–4 weeks 220+
Fractal ID 2 yes (Ethereum) 2–3 weeks 80+
Quadrata 2 yes (zk-proof) 4–5 weeks global (non-custodial)

Architectural principle: KYC data is never stored on-chain. Personal data is stored with the provider or in your encrypted database; on-chain only a hash (commitment) or credential (if using VC/SBT approach). This ensures GDPR compliance: the right to erasure is achievable if data is off-chain.

Typical mistake: storing wallet-to-identity mapping in plaintext in PostgreSQL without row-level encryption. One SQL injection and the entire KYC database is compromised. Minimum: column encryption for PII fields (PGP or AES via pgcrypto), separate key management (AWS KMS, HashiCorp Vault), audit log for all PII access.

For AML screening, we use Chainalysis, Elliptic, or TRM Labs. Integration is asynchronous via webhook: results come in 1–5 seconds. Threshold-based blocking: HIGH risk — auto-block, MEDIUM — manual review. Hold period for suspicious transactions is 24–72 hours until manual review. Sanctions screening separately: OFAC SDN list updates several times a week; we use direct OFAC list integration (free) with custom address matching logic.

How do we implement MiCA support?

Markets in Crypto-Assets Regulation (EU 2023/1114) requires CASP (Crypto-Asset Service Provider) licensing in one EU state with passporting. Technical requirements affecting development:

White paper is mandatory for issuers of ART (Asset-Referenced Tokens) and EMT (E-Money Tokens)—not a marketing document but a legally binding prospectus with technical description, holder rights, and redemption mechanisms.

Custody requirements: client assets separate from operational assets. Technically: separate wallets/accounts per client (or omnibus with off-chain mapping + regular reconciliation), no possibility to use client funds for operational needs.

Transaction monitoring and reporting: CASPs must keep records of all transactions for at least 5 years and provide them to the regulator upon request.

Travel Rule in MiCA: the threshold for VASP-to-VASP transfers is zero (not the FATF threshold). Implementation requires a Travel Rule endpoint operating 24/7.

Organization type Key MiCA requirements Technical impact
ART/EMT issuer White paper, redemption mechanism, reserve audit Smart contract with redemption function, oracle for reserve proof
CASP (exchange, custodian) License, custody segregation, Travel Rule Separate wallets per client, TRISA/TRUST integration
DeFi protocol (no issuer) Currently out of MiCA scope (review pending) Monitor, prepare architecture

Compliance infrastructure implementation process

Compliance architecture is not added on top of an existing product without pain. The correct order: compliance requirements → data model → business logic → UI. If you already have a product without a compliance layer, we start with a gap analysis: what data is already collected, where the gaps are, what will require schema migration.

  1. Gap analysis — audit of current architecture and data flow (1–2 weeks).
  2. Design — selection of KYC provider, Travel Rule protocol, AML tool, data model.
  3. Integration — connecting KYC API, implementing AML screening in the pipeline, setting up Travel Rule gateway.
  4. Testing — end-to-end tests, simulating Travel Rule handshake, verifying sanctions screening.
  5. Deployment and monitoring — rollout with feature flags, setting up alerting for compliance service errors, audit trail.
  6. License support — preparing documentation for the regulator, assisting with inspections.

What does the blockchain compliance service include?

  • Compliance architecture documentation (data flow, ER diagrams, API specifications).
  • Integration of KYC/AML/Travel Rule APIs with your backend.
  • Setup of monitoring and alerting for compliance services.
  • Training your team on tools (Chainalysis, Sumsub, etc.).
  • Support during the licensing process (MiCA, FATF).

Timeline benchmarks

  • KYC/AML integration with Sumsub or Jumio — from 3 to 6 weeks.
  • Travel Rule (TRISA or Sygna) — from 6 to 10 weeks.
  • Full compliance infrastructure for CASP licensing — from 4 to 8 months.
  • On-chain compliance via VC/SBT with ZK (MiCA-ready) — from 5 to 9 months.

Scope is refined after gap analysis. To evaluate your project, contact us—we will conduct a free analysis of your current architecture and select the optimal set of tools. Get a consultation on compliance architecture for MiCA or Travel Rule. Our team has over 7 years of blockchain development experience and 15+ deployed compliance solutions. Request an audit of your protocol for compliance with current regulatory requirements.