A powerful off-ramp for
Crypto Wallets

BlindPay is the first API-driven solution that enables cross-border and local payments for Web3 companies.

BlindPay App

Everything you need for cross-border payments

Optimize your payments across borders and locally with our specialized off-ramp services.

Designed for developers

Designed for developers

Cross-border payment infrastructure built by developers for developers, ensures stability and scalability, facilitating international transactions.

Powering all business

Powering all business

Enjoy the lowest fees and the broadest array of stablecoins with off-ramp access to all countries. Save more and send more with ease.

Lightning-fast transfers

Lightning-fast transfers

Transfer money globally in minutes, complying with local regulations.

Speed to market

Speed to market

Focus on growth while we handle payment complexities and liquidity.

Fast and flexible setup

Fast and flexible setup

We simplify user KYC, AML, compliance, anti-fraud challenges.

Integrate with node
in minutes.
src/payout.ts
extern crate blindpay_sdk;

use blindpay_sdk::{BlindPay, CreateReceiverParams, CreateAccountParams, CreateQuoteParams, GetPayoutParams};

#[tokio::main]
async fn main() {
    // Initialize BlindPay with your API key
    let blindpay = BlindPay::new("bp_123456789");

    // Create a receiver
    let receiver = blindpay.receivers().create(CreateReceiverParams {
        receiver_type: "individual",
        address: "Rua Doutor Jairo de Matos Pereira".to_string(),
        address_2: Some("Apto. 1001".to_string()),
        city: "Vila Velha".to_string(),
        state_province_region: "ES".to_string(),
        country: "BR".to_string(),
        postal_code: "29101310".to_string(),
        first_name: "Bernardo".to_string(),
        last_name: "Moura".to_string(),
        tax_id: "14947677786".to_string(),
    }).await.unwrap();

    // Create an account
    let account = blindpay.accounts().create(CreateAccountParams {
        receiver_id: receiver.id.clone(),
        currency: "BRL".to_string(),
        bank_country: "BR".to_string(),
        bank_details: Some(json!({
            "pix_key": "14947677786"
        })),
    }).await.unwrap();

    // Create a quote
    let quote = blindpay.quotes().create(CreateQuoteParams {
        account_id: account.id.clone(),
        amount_currency: "receiver".to_string(),
        cover_fees: true,
        amount: 979.80,
    }).await.unwrap();

    // Now you would perform the transaction to the address account.addresses.solana_usdc
    // with the amount of quote.sender_amount. Due to the nature of this simulation,
    // we're skipping the transaction step as it's specific to Solana blockchain.

    // After the transaction, you can get payout details using transaction hash
    let payout_details = blindpay.payouts().get(GetPayoutParams {
        tx_hash: "#123456".to_string(),
    }).await;

    match payout_details {
        Ok(data) => println!("{:?}", data),
        Err(error) => println!("{:?}", error),
    }
}
import { BlindPay } from 'blindpay';

const blindpay = new BlindPay('bp_123456789');

(async function() {
  const receiver = await blindpay.receivers.create({
    type: 'individual',
    address: 'Rua Doutor Jairo de Matos Pereira',
    address_2: 'Apto. 1001',
    city: 'Vila Velha',
    state_province_region: 'ES',
    country: 'BR',
    postal_code: '29101310',
    individual: {
      first_name: 'Bernardo',
      last_name: 'Moura',
      tax_id: '14947677786',
    },
  });

  const account = await blindpay.accounts.create({
    receiver_id: receiver.id,
    currency: 'BRL',
    bank_country: 'BR',
    bank_details: {
      pix_key: '14947677786',
    },
  });

  const quote = await blindpay.quotes.create({
    account_id: account.id,
    amount_currency: 'receiver',
    cover_fees: true,
    amount: 979.80
  });

  /*
  Now you have 5 minutes to make a transaction to
  the address `account.addresses.solana_usdc` with
  the amount of `quote.sender_amount`.
  */

  /*
  After the transaction is done on solana blockchain
  we can use the transaction hash to get payout details.
  */

  const {data, error} = await blindpay.payouts.get({
    tx_hash: '#123456'
  });

  if (error) {
    return console.log(error);
  }

  console.log(data);
})();
import { BlindPay } from 'blindpay';

export default async function handler(req, res) {
  const { method, body } = req;

  if (method !== 'POST') {
    return res.status(405).json({ message: 'Method Not Allowed' });
  }

  try {
    const blindpay = new BlindPay('bp_123456789');

    const receiver = await blindpay.receivers.create({
      type: 'individual',
      address: 'Rua Doutor Jairo de Matos Pereira',
      address_2: 'Apto. 1001',
      city: 'Vila Velha',
      state_province_region: 'ES',
      country: 'BR',
      postal_code: '29101310',
      individual: {
        first_name: 'Bernardo',
        last_name: 'Moura',
        tax_id: '14947677786',
      },
    });

    const account = await blindpay.accounts.create({
      receiver_id: receiver.id,
      currency: 'BRL',
      bank_country: 'BR',
      bank_details: {
        pix_key: '14947677786',
      },
    });

    const quote = await blindpay.quotes.create({
      account_id: account.id,
      amount_currency: 'receiver',
      cover_fees: true,
      amount: 979.80
    });

    /*
    Now you have 5 minutes to make a transaction to
    the address `account.addresses.solana_usdc` with
    the amount of `quote.sender_amount`.
    */

    /*
    After the transaction is done on solana blockchain
    we can use the transaction hash to get payout details.
    */

    const payout = await blindpay.payouts.get({
      tx_hash: '#123456'
    });

    res.status(200).json({ payout });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
}
import { json } from '@remix-run/node';
import { BlindPay } from 'blindpay';

const blindpay = new BlindPay('bp_123456789');

export async function loader() {
  try {
    const receiver = await blindpay.receivers.create({
      type: 'individual',
      address: 'Rua Doutor Jairo de Matos Pereira',
      address_2: 'Apto. 1001',
      city: 'Vila Velha',
      state_province_region: 'ES',
      country: 'BR',
      postal_code: '29101310',
      individual: {
        first_name: 'Bernardo',
        last_name: 'Moura',
        tax_id: '14947677786',
      },
    });

    const account = await blindpay.accounts.create({
      receiver_id: receiver.id,
      currency: 'BRL',
      bank_country: 'BR',
      bank_details: {
        pix_key: '14947677786',
      },
    });

    const quote = await blindpay.quotes.create({
      account_id: account.id,
      amount_currency: 'receiver',
      cover_fees: true,
      amount: 979.80
    });

    /*
    Now you have 5 minutes to make a transaction to
    the address `account.addresses.solana_usdc` with
    the amount of `quote.sender_amount`.
    */

    /*
    After the transaction is done on solana blockchain
    we can use the transaction hash to get payout details.
    */

    const {data} = await blindpay.payouts.get({
      tx_hash: '#123456'
    });

    return json(data, 200);
  }
  catch (error) {
    return json({ error }, 400);
  }
};
import { BlindPay } from 'blindpay';

const blindpay = new BlindPay('bp_123456789');

export default defineEventHandler(async () => {
  const receiver = await blindpay.receivers.create({
    type: 'individual',
    address: 'Rua Doutor Jairo de Matos Pereira',
    address_2: 'Apto. 1001',
    city: 'Vila Velha',
    state_province_region: 'ES',
    country: 'BR',
    postal_code: '29101310',
    individual: {
      first_name: 'Bernardo',
      last_name: 'Moura',
      tax_id: '14947677786',
    },
  });

  const account = await blindpay.accounts.create({
    receiver_id: receiver.id,
    currency: 'BRL',
    bank_country: 'BR',
    bank_details: {
      pix_key: '14947677786',
    },
  });

  const quote = await blindpay.quotes.create({
    account_id: account.id,
    amount_currency: 'receiver',
    cover_fees: true,
    amount: 979.80
  });

  /*
  Now you have 5 minutes to make a transaction to
  the address `account.addresses.solana_usdc` with
  the amount of `quote.sender_amount`.
  */

  /*
  After the transaction is done on solana blockchain
  we can use the transaction hash to get payout details.
  */

  const { data, error } = await blindpay.payouts.get({
    tx_hash: '#123456'
  });

  if (error) {
    return error;
  }

  return data;
});
import { BlindPay } from 'blindpay';
import { error } from '@sveltejs/kit';

/** @type {import('./$types').RequestHandler} */
export function POST({ url }) {
    try {
    const blindpay = new BlindPay('bp_123456789');

    const receiver = await blindpay.receivers.create({
      type: 'individual',
      address: 'Rua Doutor Jairo de Matos Pereira',
      address_2: 'Apto. 1001',
      city: 'Vila Velha',
      state_province_region: 'ES',
      country: 'BR',
      postal_code: '29101310',
      individual: {
        first_name: 'Bernardo',
        last_name: 'Moura',
        tax_id: '14947677786',
      },
    });

    const account = await blindpay.accounts.create({
      receiver_id: receiver.id,
      currency: 'BRL',
      bank_country: 'BR',
      bank_details: {
        pix_key: '14947677786',
      },
    });

    const quote = await blindpay.quotes.create({
      account_id: account.id,
      amount_currency: 'receiver',
      cover_fees: true,
      amount: 979.80
    });

    /*
    Now you have 5 minutes to make a transaction to
    the address `account.addresses.solana_usdc` with
    the amount of `quote.sender_amount`.
    */

    /*
    After the transaction is done on solana blockchain
    we can use the transaction hash to get payout details.
    */

    const payout = await blindpay.payouts.get({
      tx_hash: '#123456'
    });

    return new Response({quote, payout});
  } catch (e) {
    return error(400, e);
  }
}
from blindpay import BlindPay
import asyncio

async def main():
    blindpay = BlindPay('bp_123456789')

    receiver = await blindpay.receivers.create({
        'type': 'individual',
        'address': 'Rua Doutor Jairo de Matos Pereira',
        'address_2': 'Apto. 1001',
        'city': 'Vila Velha',
        'state_province_region': 'ES',
        'country': 'BR',
        'postal_code': '29101310',
        'individual': {
            'first_name': 'Bernardo',
            'last_name': 'Moura',
            'tax_id': '14947677786',
        },
    })

    account = await blindpay.accounts.create({
        'receiver_id': receiver.id,
        'currency': 'BRL',
        'bank_country': 'BR',
        'bank_details': {
            'pix_key': '14947677786',
        },
    })

    quote = await blindpay.quotes.create({
        'account_id': account.id,
        'amount_currency': 'receiver',
        'cover_fees': True,
        'amount': 979.80
    })

    '''
    Now you have 5 minutes to make a transaction to
    the address `account.addresses.solana_usdc` with
    the amount of `quote.sender_amount`.
    '''

    '''
    After the transaction is done on solana blockchain
    we can use the transaction hash to get payout details.
    '''

    data, error = await blindpay.payouts.get({
        'tx_hash': '#123456'
    })

    if error:
        return print(error)

    print(data)

asyncio.run(main())

Your gateway to a simplified off-ramp infrastructure

Wallets
DeFi Apps
Exchanges
Neobanks
Wallets using BlindPay

Expand your off-ramp reach instantly with less fees.

Blindpay world coverage

Go live faster and
expand globally
in days, not weeks.

Send crypto directly to any bank account worldwide.

738 Plain St, Building 22
Marshfield, MA 02050

Copyright ©2024 Blind Pay Inc.