DAF Pay offers Donor-Advised Fund (DAF) payments as an additional payment method. Neon Pay provides an easy-to-use checkout experience powered by Chariot Connect. While Neon Pay will display DAF donation details in Neon Pay, all DAF Pay funds are sent directly from the DAF provider to the nonprofit’s billing details as provided in Chariot.

A Note About Display:
In Neon Pay’s UI, this service is called DAF Pay and all DAF donations are referred to as DAF Distributions for display purposes. In this technical documentation, we refer to these objects as DAF donations to align with industry standard terms and our API endpoints.

Terms and Conditions

By using Neon Pay JS to integrate DAF Pay into your checkout process, you agree to and must adhere to the Chariot APIs acceptable use policy and accept the terms defined in the Chariot Terms of Service.

How It Works

Neon Pay handles much of the communication

  1. The customer interacts with the DAF Pay button
  2. This will initialize a hosted modal that guides donors through confirming the details of their DAF donation
  3. The customer accepts and authorizes the grant
  4. Neon Pay sends either a workflow session ID or a grant ID, along with updated donation amount and customer information, to your application
  5. Application sends a donation request to Neon Pay’s DAF Donation API
  6. Neon Pay sends the application the donation response
  7. Application informs their customer of the donation outcome

There are two kinds of donations supported through DAF Pay: integrated and nonintegrated. It is important to understand the difference between the two when developing your application’s integration.

Integrated Donations

Integrated donations are direct donations processed from a provider which Chariot is integrated with, such as Fidelity. Nonprofits receive the donation via check or EFT directly from the DAF provider.

They have two possible statuses: initiated and completed. They are initialized with the initiated status.

Nonintegrated Donations

Nonintegrated donations represents a donation intent from a provider that is not yet integrated with. Because DAF Pay is not yet fully integrated with the selected provider, the status of the donation cannot be confirmed by Chariot. Users are able to manually modify the status within the Neon Pay portal or applications can update it by updating the donation through the /dafDonations API.

Note: There is no Tracking ID associated with this manual transaction. There are also no fees associated with this type of DAF donation.

They have four possible statuses: unknown, initiated, canceled, and completed. They are initialized with the unknown status.

DAF Pay Fees

IMPORTANT: Only integrated donations have fees associated with them! Because nonintegrated donations are merely recorded donation intents, they do not incur any processing fees.

Both Neon Pay and Chariot have individual processing fees based on a percent of the DAF donation’s total amount. This is calculated automatically by Neon Pay and Chariot. The percentage for Neon Pay’s fee can be adjusted within the Pay portal or via the Pay API. The Chariot percent fee cannot be adjusted.

There is no need for applications to submit additional information to calculate the fee, unless they are implementing the option for donors to cover the Neon Pay percent fee.

Donor-covered Fees

Applications are responsible for updating the donation amount when a donor may choose to cover the processing fees on their donation. Remember that increasing the final amount also raises the processing fee and don’t forget to round the final amount to a whole dollar (nearest 100) as DAF donations only allow grants in dollar increments.

To calculate the final amount you can use the following formula:

Formula provided by Chariot

Neon Pay’s percent fee starts at 2% by default. Please refer to the individual merchant’s fee structure in the Pay API for the most up-to-date rate for the daf_percentage fee.

Chariot’s percent fee is 2.9%. This fee rate cannot be adjusted.

You can use setPrice() on the Neon Pay payment field to update the amount set in the DAF modal.


Neon Pay provides the following DAF donation webhooks to applications following the platform’s standard format.

daf_donation.createdA DAF donation has been created.
daf_donation_updatedA DAF donation has been updated.
daf_donation.completedA DAF donation has been completed.
daf_donation.canceledA DAF donation has been canceled.
merchant.updatedWhen a merchant has DAF donations enabled or is enrolled in Chariot.


Please note that only registered 501(c)3 organizations can accept DAF donations. If an organization has more than one 501(c)3 on the same Pay organization (i.e. more than one merchant account with unique eligible EINs), each entity will need to enroll each EIN separately to have DAF Pay appear on all eligible forms. Non-US merchant accounts are not eligible for DAF Pay.

The Neon Pay merchant must first have DAF Pay enabled and be enrolled via Chariot. Currently, it can be enabled in two ways. Neon Pay Support staff have the ability to enable it on behalf of clients from within the Neon Pay portal. Developers also can enable Apple Pay processing on behalf of merchants connected to their application through an UPDATE Merchant request to the Neon Pay API (i.e., PUT /merchants/{id}). The parameter supplied to this endpoint is has_chariot = true

Additionally, if applications create new merchant accounts through the Neon Pay API, developers will be able to enable Apple Pay processing within that POST request (i.e., POST /merchants will accept has_chariot as a parameter on creation. 

Once a merchant has DAF Pay enabled, it will need to be enrolled in the program via its EIN. Existing eligible merchants will be auto-enrolled when the DAF Pay feature initially goes live. Newly created Neon Pay merchants will be opt-in for enrollment after initial release.

IMPORTANT: Merchant enrollment is completed through the Neon Pay portal as an organization admin user. Applications are advised to create new organizations for testing or add themselves as admin users to Neon Pay organizations where they have affiliated merchant accounts, and enroll those accounts via the in-portal workflow.

Enroll a merchant via the DAFpay enrollment modal in the Neon Pay portal

You can verify if the merchant has been enrolled by checking if the chariot_connect_id parameter is filled on the Merchant object (i.e., GET /merchants/{id}).

Merchants must have both a chariot_connect_id and has_chariot = true to process DAF donations.

DAF Pay is only available through Neon Pay JS version 3.2 or later.

Integrate through Neon Pay JS

The Apple Pay button can be added to your payment page as a standalone option, with or without the standard credit card fields provided by Neon Pay JS. 

  1. If you do not already have one, generate a public API key for your application within the Neon Pay portal.
  2. Initialize the Neon Pay JS and the field object for DAF Pay in your payment form, see a developer example here.
    • This will add the DAF Pay button, which your customer will be able to interact with.
  3. Catch the DAF Pay workflow session ID (for integrated donations) or grant ID (for nonintegrated donations) via listening for Neon Pay JS’s dafAuthorized event.
    • We highly recommend that developers pass billing information as additional customer details when available. This will pre-populate the donation modal for nonintegrated donations to help reduce friction.
    • Be sure to also listen to other details returned by the dafAuthorized event, which may include additional/updated customer details such as address/email based on the information from the DAF provider system the user logged into and donation amount, which the donor can also update while going through the modal workflow. This is information that should also be passed to the DAF Donations API.
  4. Use the workflow session/grant ID and other customer details in your application’s request to Neon Pay’s DAF Donations API.
  5. Handle any errors and inform your customer about the payment’s outcome.
<form id="paymentForm" action="#" method="POST">
    <h2>Payment Form</h2>
    <div id="dafButton"></div>
    <textarea type="hidden" id="token" value=""></textarea>

<script src=""></script>
<script type="text/javascript">
    // Set up the NeonPay fields on your form
    var neonpay = new NeonPay('public_f8564752122b08cc9c20c374562d5cc7', '19');
    var daf = neonpay.createField('daf', {customerDetail: {firstName: 'John', lastName: 'Doe', amount: 1000.00});
    (async () => {
        // Check if merchant can process payments first
        const result = await neonpay.canMakePayments();

        if (result) {
        } else {
            // There was an error and the payment is not possible for this configuration
            document.querySelector('#dafButton').style.display = 'none';

    var paymentForm = document.getElementById('paymentForm');
    var tokenField = document.getElementById('token');

    // Catch the 'dafAuthorized' event and retrieve grant information to call NeonPay's /dafDonations endpoint
    // You will receive either a 'workflowSessionId' or a 'grantId' to be passed as part of the request body
    daf.on('dafAuthorized', function (event) {
        document.querySelector('#token').innerHTML = JSON.stringify(event);

Testing Your Integration

DAF Pay is supported within Neon Pay’s sandbox environment. Please develop and test your integration through the sandbox version of Neon Pay JS, available at

When you’re ready to integrate for production, use

Test Accounts for integrated donations:

When testing your integration, you can simulate logging into grant partners to create integrated donations with the following information:

user name: good-user
password: password123

Login screen for integrated DAF donations

No login information is necessary for nonintegrated donations. Complete the supplied form fields and donation options presented to you to authorize the grant.

Helpful Links

Documentation for Neon Pay’s dafDonations API endpoints