World map

Hello, Anatoly Yakovenko
We are pushing off-ramp into a new era

Developer Experience

Documentation, development instances and SDKs for multiple languages.

For Everyone

Lowest fees, dozens of stablecoins, and off-ramp to all countries.

Non Custodial

You own your KYC, transaction tracking and refund options for failed payments.

Developer Experience

Look how easy it's to send payments with BlindPay

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())
Our Team

Meet the gladiators that will beat the colosseum

Bernardo
CEO

Bernardo Simonassi

Founded a SaaS B2B and an open-source company. Worked for more than 6 years as a Software Engineer and Product Designer, transitioning from unicorn to blockchain startups.

CTO

Cairo Hoffmann

Worked for more than 5 years as a Software Engineer and over 2 years as a Blockchain Engineer, accumulating extensive experience with payment rails worldwide.

Cairo Hoffmann
Get In Touch

Feel free to schedule a meeting with us

BlindPay
738 Plain St, Building 22
Marshfield, MA 02050