Add One-Time Payment Initiation to your app 
============================================

#### Learn how to use one-time Payment Initiation in your application 

In this guide, we start from scratch and walk through how to set up a one-time [Payment Initiation](https://plaid.com/docs/api/products/payment-initiation/index.html.md) flow. For a high-level overview of all our payment related offerings, see the [Introduction to Payments (Europe)](https://plaid.com/docs/payment-initiation/index.html.md) .

For an example guide to using one-time Payment Initiation as part of an integrated onboarding flow with other Plaid products, see [Onboarding and account funding guide](https://plaid.com/docs/payment-initiation/payment-initiation-one-time/user-onboarding-and-account-funding/index.html.md) .

#### Get Plaid API keys and complete application and company profile 

If you don't already have one, you'll need to [create a Plaid developer account](https://dashboard.plaid.com/signup) . After creating your account, you can find your [API keys](https://dashboard.plaid.com/developers/keys) under the Developers menu on the Plaid Dashboard.

You will also need to complete your [application profile](https://dashboard.plaid.com/settings/company/app-branding) and [company profile](https://dashboard.plaid.com/settings/company/profile) on the Dashboard. The information in your profile will be shared with users of your application when they manage their connection on the [Plaid Portal](https://my.plaid.com) , and must be completed before connecting to certain institutions.

#### Access Payment Initiation 

Payments (Europe) is enabled in Sandbox by default. It uses test data and does not interact with financial institutions. You may need to request access to Payment Initiation via the [Dashboard](https://dashboard.plaid.com) before using it in Production.

#### Install and initialize Plaid libraries 

You can use our official server-side client libraries to connect to the Plaid API from your application:

```node
// Install via npm
npm install --save plaid

```

```bash
## Not applicable with curl calls

```

```ruby
# Available as a gem
gem install plaid

```

```java
/*
For Gradle, add the following dependency to your build.gradle and replace {VERSION} with the version number you want to use from
- https://github.com/plaid/plaid-java/releases/latest
*/
implementation "com.plaid:plaid-java:{VERSION}"

/*
For Maven, add the following dependency to your POM and replace {VERSION} with the version number you want to use from
- https://github.com/plaid/plaid-java/releases/latest
*/

  com.plaid
  plaid-java
  {VERSION}


```

```python
# Install through pip, only supports Python 3
pip install --upgrade plaid-python

```

```go
go get github.com/plaid/plaid-go

```

After you've installed Plaid's client libraries, you can initialize them by passing in your `client_id`, `secret`, and the environment you wish to connect to (Sandbox or Production). This will make sure the client libraries pass along your `client_id` and `secret` with each request, and you won't need to include them in any other calls.

```node
// Using Express
const express = require('express');
const app = express();
app.use(express.json());

const { Configuration, PlaidApi, PlaidEnvironments } = require('plaid');

const configuration = new Configuration({
  basePath: PlaidEnvironments.sandbox,
  baseOptions: {
    headers: {
      'PLAID-CLIENT-ID': process.env.PLAID_CLIENT_ID,
      'PLAID-SECRET': process.env.PLAID_SECRET,
    },
  },
});

const client = new PlaidApi(configuration);

```

```bash
## Not applicable with curl calls

```

```ruby
require 'sinatra'
require 'plaid'

set :port, ENV['APP_PORT'] || 8000

configuration = Plaid::Configuration.new
configuration.server_index = Plaid::Configuration::Environment[ENV['PLAID_ENV'] || 'sandbox']
configuration.api_key['PLAID-CLIENT-ID'] =  ENV['PLAID_CLIENT_ID']
configuration.api_key['PLAID-SECRET'] = ENV['PLAID_SECRET']

api_client = Plaid::ApiClient.new(
  configuration
)

client = Plaid::PlaidApi.new(api_client)

```

```java
import java.net.*;
import java.io.*;
import retrofit2.Response;
import java.util.Arrays;
import com.sun.net.httpserver.*;

import com.plaid.client.ApiClient;
import com.plaid.client.request.PlaidApi;

public class PlaidExample {
  private static final String CLIENT_ID = System.getenv("PLAID_CLIENT_ID");
  private static final String SECRET = System.getenv("PLAID_SECRET");

  public static void main(String[] args) {
    HttpServer server = HttpServer.create(
      new InetSocketAddress("localhost", 8000), 0);
    server.createContext("/create_link_token", new GetLinkToken());
    server.setExecutor(null);
    server.start();
  }

  // Additional server code goes here

}

```

```python
import plaid
from plaid.api import plaid_api

from flask import Flask
from flask import render_template
from flask import request
from flask import jsonify

app = Flask(name)

configuration = plaid.Configuration(
  host=plaid.Environment.Sandbox,
  api_key={
    'clientId': PLAID_CLIENT_ID,
    'secret': PLAID_SECRET,
  }
)

api_client = plaid.ApiClient(configuration)
client = plaid_api.PlaidApi(api_client)

# Additional server code goes here

if __name__ == "__main__":
    app.run(port=8000)

```

```go
import (
    "context"
    "net/http"
    "os"

    "github.com/gin-gonic/gin"
    "github.com/plaid/plaid-go/v3/plaid"
)


configuration := plaid.NewConfiguration()
configuration.AddDefaultHeader("PLAID-CLIENT-ID", os.Getenv("CLIENT_ID"))
configuration.AddDefaultHeader("PLAID-SECRET", os.Getenv("SECRET"))
configuration.UseEnvironment(plaid.Sandbox)
client := plaid.NewAPIClient(configuration)


func main() {
  r := gin.Default()
  // Server endpoints would be declared here
  // e.g.  r.POST("/create_link_token", createLinkToken)
 r.POST("/create_link_token", createLinkToken)

  err := r.Run(":8000")
  if err != nil {
    panic("unable to start server")
  }
}

```

#### One-time Payment Initiation flow overview 

Before we jump into the code, let's see an overview of the steps needed to set up your payment with Plaid:

**1**Your app collects information of the sender and the recipient, as well as the payment amount.

(An image of "Step 1 diagram")

**2**With this information, [create a recipient](https://plaid.com/docs/api/products/payment-initiation/index.html.md#payment_initiationrecipientcreate) and obtain a `recipient_id`. You can reuse this `recipient_id` for future payments.

(An image of "Step 2 diagram")

**3**Provide the `recipient_id` to Plaid when you [create a payment](https://plaid.com/docs/api/products/payment-initiation/index.html.md#payment_initiationpaymentcreate) . Store the resulting `payment_id` along with your payment metadata.

(An image of "Step 3 diagram")

**4**From your backend, use the `payment_id` to [create a link\_token](https://plaid.com/docs/api/link/index.html.md#linktokencreate) .

(An image of "Step 4 diagram")

**5**Your client app uses the `link_token` to initiate a Link flow for your user. The onSuccess callback signals that the payment has been initiated.

(An image of "Step 5 diagram")

**6**Your backend listens for [PAYMENT\_STATUS\_UPDATE](https://plaid.com/docs/api/products/payment-initiation/index.html.md#payment_status_update) webhooks to keep track of the payment's status.

(An image of "Step 6 diagram")

##### Create a recipient 

Before beginning the payment initiation process, you will need to know the name and account information of the recipient. With this information in hand, you can then call [/payment\_initiation/recipient/create](https://plaid.com/docs/api/products/payment-initiation/index.html.md#payment_initiationrecipientcreate) to create a payment recipient and receive a `recipient_id`. You can later reuse this `recipient_id` for future payments to the same account.

```node
const { PaymentInitiationRecipientCreateRequest } = require('plaid');

// Using BACS, without IBAN or address
const request: PaymentInitiationRecipientCreateRequest = {
  name: 'John Doe',
  bacs: {
    account: '26207729',
    sort_code: '560029',
  },
};
try {
  const response = await plaidClient.paymentInitiationRecipientCreate(request);
  const recipientID = response.data.recipient_id;
} catch (error) {
  // handle error
}

```

```bash
curl -X POST https://sandbox.plaid.com/payment_initiation/recipient/create \
-H 'Content-Type: application/json' \
-d '{
 "client_id": "${PLAID_CLIENT_ID}",
 "secret": "${PLAID_SECRET}",
 "name": String,
 "iban": String,
 "bacs": Object,
 "address": Object
}'

```

```ruby
require 'plaid'

request = Plaid::PaymentInitiationRecipientCreateRequest.new(
 {
 name: "John Doe",
 iban: "GB33BUKB20201555555555",
 address: {
      street: ["Street Name 999"],
      city: "City",
      postal_code: "99999",
      country: "GB",
    },
 bacs: {
      account: "26207729",
      sort_code: "560029",
    }
 }
)
response = client.payment_initiation_recipient_create(request)
recipient_id = response.recipient_id

```

```java
import com.plaid.client.model.PaymentInitiationRecipientCreateRequest;
import com.plaid.client.model.PaymentInitiationRecipientCreateResponse;
import com.plaid.client.model.NullableRecipientBACS;
import com.plaid.client.model.PaymentInitiationAddress;

PaymentInitiationAddress address = new PaymentInitiationAddress()
  .street(Arrays.asList("Street Name 999"))
  .city("City")
  .postalCode("99999")
  .country("GB");
NullableRecipientBACS bacs = new NullableRecipientBACS()
  .account("26207729")
  .sortCode("560029");

PaymentInitiationRecipientCreateRequest request = new PaymentInitiationRecipientCreateRequest()
  .name("John Doe")
  .bacs(bacs)
  .address(address);

Response response = client
  .paymentInitiationRecipientCreate(request)
  .execute();

```

```python
import plaid
from plaid.model.payment_initiation_recipient_create_request import PaymentInitiationRecipientCreateRequest

request = PaymentInitiationRecipientCreateRequest(
    name='John Doe',
    iban='GB33BUKB20201555555555',
    address=PaymentInitiationAddress(
        street=['street name 999'],
        city='city',
        postal_code='99999',
        country='GB'
    )
)
response = client.payment_initiation_recipient_create(request)
recipient_id = response["recipient_id"]

```

```go
import (
    "context"

    "github.com/plaid/plaid-go/v42/plaid"
)

request := plaid.NewPaymentInitiationRecipientCreateRequest("John Doe")
request.SetBacs(plaid.RecipientBACSNullable{
 Account:  plaid.PtrString("26207729"),
 SortCode: plaid.PtrString("560029"),
})
request.SetAddress(*plaid.NewPaymentInitiationAddress([]string{"Street Name 999"},
  "City",
  "99999",
  "GB",
))
paymentRecipientCreateResp, _, err := client.PlaidApi.PaymentInitiationRecipientCreate(ctx).PaymentInitiationRecipientCreateRequest(*request).Execute()

```

##### Create a payment 

Now that you have the `recipient_id`, you can provide it together with the payment amount to [/payment\_initiation/payment/create](https://plaid.com/docs/api/products/payment-initiation/index.html.md#payment_initiationpaymentcreate) , which returns a `payment_id`.

```go
import (
    "context"

    "github.com/plaid/plaid-go/v42/plaid"
)

request := plaid.NewPaymentInitiationPaymentCreateRequest(
  recipientID,
  "TestPayment",
  *plaid.NewPaymentAmount("GBP", 100.0),
)

response, _, err := client.PlaidApi.PaymentInitiationPaymentCreate(ctx).PaymentInitiationPaymentCreateRequest(*request).Execute()

```

```python
import plaid
from plaid.model.payment_initiation_payment_create_request import PaymentInitiationPaymentCreateRequest

request = PaymentInitiationPaymentCreateRequest(
    recipient_id=recipient_id,
    reference='TestPayment',
    amount=Amount(
        currency='GBP',
        value=100.00
    )
)
response = client.payment_initiation_payment_create(request)
payment_id = response["payment_id"]
status = response["status"]

```

```java
import com.plaid.client.model.PaymentInitiationPaymentCreateRequest;
import com.plaid.client.model.PaymentInitiationPaymentCreateResponse;

PaymentAmount amount = new PaymentAmount()
  .currency(PaymentAmount.CurrencyEnum.GBP)
  .value(999.99);

PaymentInitiationPaymentCreateRequest request = new PaymentInitiationPaymentCreateRequest()
  .recipientId(recipientId)
  .reference("reference")
  .amount(amount);

Response response = client
  .paymentInitiationPaymentCreate(request)
  .execute();

```

```bash
curl -X POST https://sandbox.plaid.com/payment_initiation/payment/create \
-H 'Content-Type: application/json' \
-d '{
 "client_id": "${PLAID_CLIENT_ID}",
 "secret": "${PLAID_SECRET}",
 "recipient_id": String,
 "reference": String,
 "amount": Object,
 "schedule": Object
}'

```

```ruby
require 'plaid'

request = Plaid::PaymentInitiationPaymentCreateRequest.new(
 {
 recipient_id: recipient_id,
 reference: "testpayment",
 amount: {
      value: 100.00,
      currency: "GBP"
    }
 }
)
response = client.payment_initiation_payment_create(request)
payment_id = response.payment_id
status = response.status

```

```node
const { PaymentInitiationPaymentCreateRequest } = require('plaid');

const request: PaymentInitiationPaymentCreateRequest = {
  recipient_id: recipientID,
  reference: 'TestPayment',
  amount: {
    currency: 'GBP',
    value: 100.0,
  },
};
try {
  const response = await plaidClient.paymentInitiationPaymentCreate(request);
  const paymentID = response.data.payment_id;
  const status = response.data.status;
} catch (error) {
  // handle error
}

```

Make sure to store the `payment_id` in your backend together with your own metadata (e.g. your internal `user_id`). You can use this later to process the [payment status updates](https://plaid.com/docs/api/products/payment-initiation/index.html.md#webhooks)

##### Create a link\_token 

Before initializing Link, you need to create a new `link_token` on the server side of your application. A `link_token` is a short-lived, one-time use token that is used to authenticate your app with Link. You can create one using the [/link/token/create](https://plaid.com/docs/api/link/index.html.md#linktokencreate) endpoint. Then, on the client side of your application, you'll need to initialize Link with the `link_token` that you created. This will bring up the payment initiation flow in Link that allows your end user to confirm the payment.

When calling [/link/token/create](https://plaid.com/docs/api/link/index.html.md#linktokencreate) to create a token for use with Payment Initiation, you provide the `payment_id` and specify `payment_initiation` as the product.

While it is possible to initialize Link with many products, `payment_initiation` cannot be specified along with any other products and must be the only product in Link's product array if it is being used.

In the code samples below, you will need to replace `PLAID_CLIENT_ID` and `PLAID_SECRET` with your own keys, which you can get from the [Dashboard](https://dashboard.plaid.com/developers/keys) .

```node
// Using Express
app.post('/api/create_link_token', async function (request, response) {
  const configs = {
    user: {
      // This should correspond to a unique id for the current user.
      client_user_id: 'user-id',
    },
    client_name: 'Plaid Test App',
    products: [Products.PaymentInitiation],
    language: 'en',
    webhook: 'https://webhook.sample.com',
    country_codes: [CountryCode.Gb],
    payment_initiation: {
      payment_id: paymentID,
    },
  };
  try {
    const createTokenResponse = await client.linkTokenCreate(configs);
    response.json(createTokenResponse.data);
  } catch (error) {
    // handle error
  }
});

```

```bash
curl -X POST https://sandbox.plaid.com/link/token/create \
-H 'Content-Type: application/json' \
-d '{
  "client_id": "${PLAID_CLIENT_ID}",
  "secret": "${PLAID_SECRET}",
  "client_name": "Plaid Test App",
  "user": { "client_user_id": "${UNIQUE_USER_ID}" },
  "products": ["payment_initiation"],
  "country_codes": ["GB"],
  "language": "en",
  "webhook": "https://webhook.sample.com",
  "payment_initiation": { "payment_id": "${PAYMENT_ID}" },
}'

```

```ruby
require 'sinatra'
require 'plaid'

post '/api/create_link_token' do
  # Create a link_token for the given user
  link_token_create_request = Plaid::LinkTokenCreateRequest.new(
    {
      user: { client_user_id: 'user-id' },
      client_name: 'Plaid Test App',
      products: ['payment_initiation'],
      country_codes: ['GB'],
      language: "en",
      redirect_uri: nil_if_empty_envvar('PLAID_REDIRECT_URI'),
      webhook: 'https://webhook.sample.com',
      payment_initiation: { payment_id: payment_id}
    }
  )
  response = client.link_token_create(link_token_create_request)
  content_type :json
  response.to_json
end

```

```java

import com.plaid.client.model.LinkTokenCreateRequest;
import com.plaid.client.model.LinkTokenCreateRequestUser;
import com.plaid.client.model.LinkTokenCreateResponse;


static class GetLinkToken implements HttpHandler {
  private static PlaidClient plaidClient;

  public void handle(HttpExchange t) throws IOException {
    // Create your Plaid client
    HashMap apiKeys = new HashMap();
    apiKeys.put("clientId", CLIENT_ID);
    apiKeys.put("secret", SECRET);
    apiKeys.put("plaidVersion", "2020-09-14");
    apiClient = new ApiClient(apiKeys);
    apiClient.setPlaidAdapter(ApiClient.Sandbox);

    plaidClient = apiClient.createService(PlaidApi.class);

    // Simplified pseudo-code for obtaining a user_id
    User userFromDB = db.find(...);
    String clientUserId = userFromDB.id;
    LinkTokenCreateRequestUser user = new LinkTokenCreateRequestUser()
      .clientUserId(clientUserId);

    // Create a link_token for the given user
    LinkTokenCreateRequestPaymentInitiation paymentInitiation = new LinkTokenCreateRequestPaymentInitiation()
    .paymentId(paymentId);

    LinkTokenCreateRequest request = new LinkTokenCreateRequest()
      .user(user)
      .clientName("Plaid Test App")
      .products(Arrays.asList(Products.PAYMENT_INITIATION))
      .countryCodes(Arrays.asList(CountryCode.GB))
      .language("en")
      .redirectUri(redirectUri)
      .webhook("https://sample.webhook.com")
      .paymentInitiation(paymentInitiation);

    Response response = plaidClient
      .linkTokenCreate(request)
      .execute();

    // Send the data to the client
    return response.body();
  }
}


```

```python
import plaid

# Using Flask
@app.route("/create_link_token", methods=['POST'])
def create_link_token():
    # Get the client_user_id by searching for the current user
    user = User.find(...)
    client_user_id = user.id

    # Create a link_token for the given user
    request = LinkTokenCreateRequest(
            products=[Products('payment_initiation')],
            client_name="Plaid Test App",
            country_codes=[CountryCode('GB')],
            language='en',
            webhook='https://webhook.sample.com',
            payment_initiation=LinkTokenCreateRequestPaymentInitiation(
                payment_id=payment_id
            ),
            user=LinkTokenCreateRequestUser(
                client_user_id=client_user_id
            )
        )
    response = client.link_token_create(request)
    link_token = response['link_token']

    # Send the data to the client
    return jsonify(response.to_dict())


```

```go
import (
    "context"
    "net/http"
    "os"

    "github.com/gin-gonic/gin"
    "github.com/plaid/plaid-go/plaid"
)


func createLinkToken(c *gin.Context) {
  ctx := context.Background()

  // Get the client_user_id by searching for the current user
  user, _ := usermodels.Find(...)
  clientUserId := user.ID.String()

  // Create a link_token for the given user
  paymentInitiationReq := plaid.NewLinkTokenCreateRequestPaymentInitiation()
  request := plaid.NewLinkTokenCreateRequest("Plaid Test App", "en", []plaid.CountryCode{plaid.COUNTRYCODE_GB}, *plaid.NewLinkTokenCreateRequestUser(clientUserId))
  request.SetWebhook("https://webhook.sample.com")
  request.SetProducts([]plaid.Products{plaid.PRODUCTS_PAYMENT_INITIATION})
  request.SetPaymentInitiation(*paymentInitiationReq)

    resp, _, err := testClient.PlaidApi.LinkTokenCreate(ctx).LinkTokenCreateRequest(*request).Execute()

  // Send the data to the client
  c.JSON(http.StatusOK, gin.H{
    "link_token": resp.GetLinkToken(),
  })
}


```

Once you have exposed an endpoint to create a `link_token` in your application server, you now need to configure your client application to import and use Link.

#### Launch the payment initiation flow in Link 

Plaid Link is a drop-in module that provides a secure, elegant authentication flow for the many financial institutions that Plaid supports. Link makes it secure and easy for users to connect their bank accounts to Plaid. Because Link has access to all the details of the payment at the time of initialisation, it will display a screen with the payment details already populated. All your end user has to do is log in to their financial institution through a Link-initiated OAuth flow, select a funding account, and confirm the payment details.

(An image of "Plaid Link payment flow: View payment details, select bank, authenticate with bank, payment confirmation with bank and transaction info.")

Note that these instructions cover Link on the web. For instructions on using Link within mobile apps, see the [Link documentation](https://plaid.com/docs/link/index.html.md) . If you want to customise Link's look and feel, you can do so from the [Dashboard](https://dashboard.plaid.com/link) .

##### Install Link dependency 

index.html

```html
<head>
  <title>Link for Payment Initiation</title>
  <script src="https://cdn.plaid.com/link/v2/stable/link-initialize.js"></script>
</head>
```

##### Configure the client-side Link handler 

Plaid communicates to you certain events that relate to how the user is interacting with Link. What you do with each of these event triggers depends on your particular use case, but a basic scaffolding might look like this:

app.js

```javascript
const linkHandler = Plaid.create({
  // Create a new link_token to initialize Link
  token: (await $.post('/create_link_token')).link_token,
  onSuccess: (public_token, metadata) => {
    // Show a success page to your user confirming that the
    // payment will be processed.
    //
    // The 'metadata' object contains info about the institution
    // the user selected.
    // For example:
    //  metadata  = {
    //    link_session_id: "123-abc",
    //    institution: {
    //      institution_id: "ins_117243",
    //      name:"Monzo"
    //    }
    //  }
  },
  onExit: (err, metadata) => {
    // The user exited the Link flow.
    if (err != null) {
      // The user encountered a Plaid API error prior to exiting.
    }
    // 'metadata' contains information about the institution
    // that the user selected and the most recent API request IDs.
    // Storing this information can be helpful for support.
  },
  onEvent: (eventName, metadata) => {
    // Optionally capture Link flow events, streamed through
    // this callback as your users connect with Plaid.
    // For example:
    //  eventName = "TRANSITION_VIEW",
    //  metadata  = {
    //    link_session_id: "123-abc",
    //    mfa_type:        "questions",
    //    timestamp:       "2017-09-14T14:42:19.350Z",
    //    view_name:       "MFA",
    //  }
  },
});

linkHandler.open();
```

Unlike other products, for `payment_initiation` it is not necessary to exchange the `public_token` for an `access_token`. You only need the `payment_id` to interact with the `payment_initiation` endpoints.

#### Verify payment status 

##### Listening for status update webhooks 

Once the payment has been authorised by the end user and the Link flow is completed, the `onSuccess` callback is invoked, signaling that the payment status is now `PAYMENT_STATUS_INITIATED`.

From this point on, you can track the payment status using the [PAYMENT\_STATUS\_UPDATE](https://plaid.com/docs/api/products/payment-initiation/index.html.md#payment_status_update) webhook that is triggered by Plaid when updates occur:

*   Updates are sent by Plaid to the [configured webhook URL](https://plaid.com/docs/api/link/index.html.md#link-token-create-request-webhook) to indicate that the status of an initiated payment has changed. All Payment Initiation webhooks have a [webhook\_type](https://plaid.com/docs/api/products/payment-initiation/index.html.md#PaymentStatusUpdateWebhook-webhook-type) of `PAYMENT_INITIATION`.
*   Once you receive the status update, use the [payment\_id](https://plaid.com/docs/api/products/payment-initiation/index.html.md#PaymentStatusUpdateWebhook-payment-id) field to retrieve the payment's metadata from your database.
*   From the status update object, use the [new\_payment\_status](https://plaid.com/docs/api/products/payment-initiation/index.html.md#PaymentStatusUpdateWebhook-new-payment-status) field to decide what action needs to be taken for this payment. For example, you may treat `PAYMENT_STATUS_INITIATED` as your primary success signal, with `PAYMENT_STATUS_EXECUTED` as supplementary confirmation if and when it arrives, or notify the user that their payment got rejected (`PAYMENT_STATUS_REJECTED`).

`PAYMENT_STATUS_SETTLED` is the only status that can be used for releasing funds to end users or merchants. For all other statuses, including `PAYMENT_STATUS_INITIATED` and `PAYMENT_STATUS_EXECUTED`, you must wait until you have confirmed the funds have arrived in your own bank account, or until the payment transitions to `PAYMENT_STATUS_SETTLED`.

For more information, see [Payment Status](https://plaid.com/docs/payment-initiation/payment-status/index.html.md) .

For more information on how to implement your webhook listener, see the [webhooks documentation](https://plaid.com/docs/api/webhooks/index.html.md) .

#### Sample code in Plaid Pattern 

For an example implementation of Payment Initiation, see the [Payment Initiation Pattern App](https://github.com/plaid/payment-initiation-pattern-app) on GitHub, which uses Payment Initiation in an account funding use case.