Exemple d'application Issuing et de Financial Accounts pour les plateformes

Utilisez l'application de test Stripe Next.js pour démarrer votre propre intégration Issuing et Financial Accounts pour les plateformes.

En plus d’une suite complète de documentation et de SDK pour Stripe Issuing et Financial Accounts pour les plateformes, nous proposons une application test Next.js.

Visionnez une démo de notre application test sur baas.stripe.dev ou consultez le référentiel GitHub.

Accès au code

L’application test est une application Next.js qui exploite TypeScript, React et Material UI. Vous pouvez créer un fork du projet à partir du référentiel GitHub d’exemples Stripe et utiliser les composants inclus comme point de départ pour votre propre application.

Fonctionnalités de l’application

L’application fournit de nombreux exemples pratiques, notamment :

Tirez parti de Stripe Connect Onboarding pour collecter les informations Know Your Customer (KYC) afin d’inscrire les comptes connectés en toute conformité
Afficher les informations et le solde du compte
Afficher les transactions sur le compte financier
Simulez l’envoi de fonds vers un compte externe par ACH ou par virement bancaire
Simulez la réception d’un virement ACH
Visualisez le volume des flux d’argent entrants et sortants à l’aide d’ApexCharts
Créez des titulaires de carte en toute conformité
Créer des cartes en utilisant le compte financier comme solde d’émission
Affichez les numéros de cartes sensibles conformément à la norme PCI
Simuler des autorisations de carte bancaire
Faites-vous payer via un lien de paiement, puis transférez des fonds de votre solde Stripe vers le compte financier
Utilisez des outils d’aide aux tests pour simuler des actions affectant le compte

Détails des composants

Les sections suivantes fournissent une vue d’ensemble du fonctionnement de chaque composant de l’application test.

Vous pouvez en savoir plus sur les API et les fonctionnalités d’Issuing ou sur les API du compte financieret les fonctionnalités.

Création de compte

Le flux de création de compte comprend quatre étapes :

Créez un compte connecté avec les fonctionnalités suivantes : transferts, card_issuing et trésorerie.

const account = await stripe.accounts.create({
  country: 'US',
  email: email,
  capabilities: {
    transfers: {requested: true},
    treasury: {requested: true},
    card_issuing: {requested: true},
  },
  controller: {
    dashboard: {type: "none"},
    losses: {payments: "application"},
    requirement_collection: "application",
    fees: {payer: "application"}
  },
});

Créer un compte financier.

const financialAccount = await stripe.treasury.financialAccounts.create(
  {
    supported_currencies: ['usd'],
    features: {
      card_issuing: {requested: true},
      deposit_insurance: {requested: true},
      financial_addresses: {aba: {requested: true}},
      inbound_transfers: {ach: {requested: true}},
      intra_stripe_flows: {requested: true},
      outbound_payments: {
        ach: {requested: true},
        us_domestic_wire: {requested: true},
      },
      outbound_transfers: {
        ach: {requested: true},
        us_domestic_wire: {requested: true},
      },
    },
  },
  {stripeAccount: account.id},
);

Créez un lien Connect Onboarding et utilisez-le pour rediriger les nouveaux comptes connectés afin de collecter les informations de profil nécessaires pour les fonctionnalités demandées.

const { url } = await stripe.accountLinks.create({
  type: 'account_onboarding',
  account: accountId,
  refresh_url: host + '/onboard',
  return_url: host + '/onboard',
  collect: 'eventually_due',
});

Solde du compte

La carte de solde du compte utilise uniquement l’API stripe.treasury.financialAccounts.list.

const financialAccounts = await stripe.treasury.financialAccounts.list({
  stripeAccount: StripeAccountID,
});
const financialAccount = financialAccounts.data[0];

La charge utile de la commande ci-dessus contient un objet solde composé du solde actuel (espèces) et des fonds sortants.

{
  "id": "fa_...",
 ...
  "balance": {
    "cash": { "usd": 534214 },
    "inbound_pending": { "usd": 0 },
    "outbound_pending": { "usd": 2200 }
  },
 ...
  "supported_currencies": [ "usd" ]
}

Graphique des entrées et sorties de fonds

Le graphique des mouvements de fonds utilise uniquement l’API stripe.treasury.transactions.list.

const fa_transactions = await stripe.treasury.transactions.list(
  {
    financial_account: financialAccount.id,
    order_by: 'created',
    limit: 100,
  },
  {stripeAccount: StripeAccountID},
);

Les réponses sont regroupées par solde positif ou négatif et par date de création. Les données sont ensuite transférées dans ApexCharts pour créer un affichage dynamique du flux de fonds.

{
  "id": "{{TRANSACTION_ID}}",
  "object": "treasury.transaction",
  "created": "{{T}}",
  ...
  "flow": "{{OUTBOUND_PAYMENT_ID}}",
  "flow_type": "outbound_payment",
  "status": "open",
  "amount": -1000,
  "currency": "usd",
  "balance_impact": {
    "cash": -1000,
    "inbound_pending": 0,
    "outbound_pending": 1000,
  },
  "entries": {
    "data": [
      {
        "id": "{{TRANSACTION_ENTRY_ID}}",
        "object": "treasury.transaction_entry",
        ...
        "created": "{{T}}",
        "effective_at": "{{T}}",
        "currency": "usd",
        "balance_impact": {
          "cash": -1000,
          "inbound_pending": 0,
          "outbound_pending": 1000,
        }
      }
    ],
    "has_more": false,
    "object": "list",
    "url": "/v1/treasury/transaction_entries?financial_account={{FINANCIAL_ACCOUNT_ID}}&transaction={{TRANSACTION_ID}}"
  }
}

Liste des transactions

La liste des transactions utilise l’API stripe.treasury.transactions.list.

const fa_transactions = await stripe.treasury.transactions.list(
  {
    financial_account: financialAccount.id,
    order_by: 'created',
    limit: 100,
  },
  {stripeAccount: StripeAccountID},
);

Les colonnes de la table des transactions sont analysées à partir de l’objet transaction à l’aide du mappage suivant :

created → Date
amount → Montant/Devise
flow_type → Type
status → État
description → Description

Interface d’envoi de fonds

La fonctionnalité d’envoi de fonds de l’application de test utilise la fonctionnalité OutboundPayment des Financial Accounts pour les plateformes. Vous pouvez utiliser OutboundPayment pour envoyer des fonds vers le compte externe d’un tiers.

const outboundPayment = await stripe.treasury.outboundPayments.create(
  {
    financial_account: financialAccount.id,
    amount: amount,
    currency: 'usd',
    statement_descriptor: req.descriptor,
    destination_payment_method_data: {
      type: 'us_bank_account',
      us_bank_account: {
        account_holder_type: 'individual',
        routing_number: '110000000',
        account_number: '000000000009',
      }
    }
  },
  {
    stripeAccount: StripeAccountId
  },
);

Création d’un titulaire de carte Issuing

Vous devez créer un titulaire de la carte avant de pouvoir émettre une carte bancaire avec Stripe Issuing pour dépenser des fonds du compte financier. Utilisez l’API stripe.issuing.cardholders.create pour créer des titulaires de carte.

const cardholder = await stripe.issuing.cardholders.create(
  {
    type: 'individual',
    name: firstName + ' ' + lastName,
    email: email,
    individual: {
      first_name: firstName,
      last_name: lastName,
      dob: {day: day, month: month, year: year}
    },
    billing: {
      address: {
        city: city,
        line1: address1,
        state: state,
        postal_code: postalCode,
        country: country,
      },
    },
  },
  {
    stripeAccount: StripeAccountId,
  }
);

Émission de cartes

Après avoir créé un Cardholder, vous pouvez émettre une carte pour le Cardholder à l’aide de l’API stripe.issuing.cards.create.

const card = await stripe.issuing.cards.create(
  {
    cardholder: req.body.cardholderid,
    financial_account: financialAccount.id,
    currency: 'usd',
    type: 'virtual',
    status: 'active',
  },
  {stripeAccount: StripeAccountId},
);

Liste des cartes

La liste des cartes bancaires s’affiche à l’aide des données de l’API stripe.issuing.cards.list.

const cards = await stripe.issuing.cards.list(
  {limit: 10},
  {stripeAccount: StripeAccountID},
);

Liste des autorisations de carte bancaire

Utilisez l’API stripe.issuing.authorizations.list pour récupérer les autorisations pour une carte spécifique. L’exemple suivant limite la liste aux 10 autorisations les plus récentes.

const card_authorizations = await stripe.issuing.authorizations.list(
  {
    card: cardId,
    limit: 10,
  },
  {stripeAccount: StripeAccountID},
);

Les colonnes de la table des autorisations sont analysées à partir de l’objet de réponse à l’aide du mappage suivant :

created → Date
amount → Montant/Devise du montant
card.cardholder.name → Nom sur la carte bancaire
card.last4 → Les 4 derniers chiffres de la carte bancaire
approved → Approuvé
status → État
merchant_data.name → Marchand
merchant_data.category → Catégorie de marchand

Assistants de test

L’application de test comprend des fonctionnalités d’aide en mode test qui vous permettent d’effectuer certaines actions, par exemple approvisionner votre compte, créer un lien de paiement pour collecter des fonds dans un compte connecté et virer des fonds sur le compte financier. Vous pouvez accéder à la plupart des outils d’aide en mode test en cliquant sur le bouton Générer des données de test ou sur Données de test.

Outil d’aide au test pour les crédits reçus

En mode test, vous pouvez ajouter des fonds à un compte financier à l’aide des assistants de test ReceivedCredit. Cet outil d’aide au test simule la réception d’un transfert d’un compte bancaire externe vers votre compte financier.

const receivedCredit = await stripe.testHelpers.treasury.receivedCredits.create(
  {
    amount: 50000,
    currency: 'usd',
    financial_account: financialAccount.id,
    network: 'ach',
  },
  {stripeAccount: StripeAccountId},
);

Liens de paiement et virements

Vous pouvez utiliser des liens de paiement pour ajouter des fonds au compte connecté associé à un compte financier :

Créez un Price correspondant au montant qui sera déposé sur le compte connecté une fois le paiement finalisé.

const prices = await stripe.prices.list(
  {
    limit: 1,
    active: true,
    type: 'one_time',
  },
  {stripeAccount: StripeAccountId,},
);

let price;

if (prices.data.length < 1) {
  price = await stripe.prices.create(
    {
      unit_amount: 1000,
      currency: 'usd',
      product_data:
        {
          name: 'Unit',
      },
    },
    {stripeAccount: StripeAccountId,},
  );
} else {
  price = prices.data[0];
}

Une fois le tarif obtenu, Stripe crée un PaymentLink, tandis que vous redirigez le client pour qu’il finalise le paiement. Utilisez l’id de Price de l’étape précédente pour définir la valeur du paramètre price. Vous pouvez également exclure le paramètre pour utiliser une valeur par défaut à la place.

const paymentLink = await stripe.paymentLinks.create(
  {
    line_items: [
      {
        price: price.id,
        quantity: 1,
        adjustable_quantity: {enabled: true},
      },
    ],
  },
  {stripeAccount: StripeAccountId,},
);

Virement à partir du solde des paiements du compte connecté

Les virements permettent d’envoyer des fonds depuis le solde des paiements d’un compte connecté vers leur compte financier. Pour effectuer un paiement, procédez comme suit :

Vérifiez si un compte externe est configuré pour le compte connecté. À cet effet, utilisez l’API accounts.retrieve pour obtenir l’objet Account et vérifiez si la propriété external_account est renseignée.

const responseAccount = await stripe.accounts.retrieve(StripeAccountID);
const accountExternalAccount = responseAccount.external_accounts.data[0];

let hasExternalAccount = false;

if (accountExternalAccount) {
  hasExternalAccount = true;
}

Si le compte connecté ne dispose pas de compte externe, il peut configurer le compte financier en tant que compte externe.

const financialAccounts = await stripe.treasury.financialAccounts.list(
  {expand: ['data.financial_addresses.aba.account_number']},
  {
    stripeAccount: StripeAccountId,
  },
);

const financialAccount = financialAccounts.data[0];

await stripe.accounts.createExternalAccount(StripeAccountId, {
  external_account: {
    object: 'bank_account',
    country: 'US',
    currency: 'usd',
    account_number:
      financialAccount.financial_addresses[0].aba.account_number,
    routing_number:
      financialAccount.financial_addresses[0].aba.routing_number,
  },
});

Initiez un virement vers le compte externe du compte connecté. Dans notre cas, le compte externe est le compte financier.

const balance = await stripe.balance.retrieve({
  stripeAccount: StripeAccountId,
});

const payout = await stripe.payouts.create(
  {
    amount: balance.available[0].amount,
    currency: 'usd',
  },
  {stripeAccount: StripeAccountId},
);