Version: 1.28 (Current)

Make a payment with Electronic Check

Audience: Low-code Engineers

Skill Prerequisites: Actions, Tokens, Authorize.Net account

Takes a payment from a bank account through Authorize.Net eCheck. The bank details are sent from your server to Authorize.Net, and the action then runs one of four action lists, depending on whether the payment was approved, declined, held for review or ended in an error.

Your Authorize.Net account must have eCheck enabled.

note

This action is part of the Authorize.Net add-on (DnnSharp.Authorize.Net). The add-on is installed separately and needs the AUTHORIZE feature in your license. If it isn't licensed, the action fails with a "not licensed" error. If you don't see the Authorize.Net actions, the add-on isn't installed.

`Typical Use Cases`

Let customers pay an invoice or order from their checking or savings account
Take a payment authorized over the phone
Convert a paper check received by mail into an electronic payment
Save the transaction ID, so the payment can be refunded later with Refund a Transaction

`Don't use it to`

Charge a credit card. Use Make a payment with Credit Card instead.
Set up recurring payments. Use Create Subscription instead.
Refund a settled payment. Use Refund a Transaction instead.

`Related Actions`

Action Name	Description
Make a payment with Credit Card	Charges a credit card instead of a bank account.
Refund a Transaction	Refunds a settled transaction by its transaction ID.
Create Subscription	Creates a recurring payment in Authorize.Net.
Update Subscription	Changes an existing Authorize.Net subscription.

`Input Parameter Reference`

In Forms and API endpoints, the bank and billing parameters are dropdowns where you pick a field, or switch to an expression. In other modules they're text boxes where you type a value or tokens, for example [RoutingNumber].

Parameter	Description	Supports Tokens	Default	Required
API Login ID	The API Login ID of your Authorize.Net account. Use the sandbox login when Go Live is off.	Yes	`empty string`	Yes
Transaction Key	The Transaction Key that goes with the API Login ID.	Yes	`empty string`	Yes
Credit Card Transaction Type	The Authorize.Net transaction type. Despite its name, it's used for eChecks too. The options are `AUTH_CAPTURE`, `AUTH_ONLY`, `CAPTURE_ONLY`, `PRIOR_AUTH_CAPTURE`, `CREDIT` and `VOID`, but Authorize.Net only supports some of them for eChecks. If it's empty, the payment is processed as `AUTH_CAPTURE`.	Yes	`empty string`	No
Go Live	When on, the payment goes to the production gateway and the account is really debited. When off, it goes to the Authorize.Net sandbox (`https://test.authorize.net/gateway/transact.dll`).	Yes	`false`	No
Payment description	What the payment is for, for example a product or service name. It's shown on receipts and in Authorize.Net.	Yes	`empty string`	No
Transaction's currency	The currency code: `AUD`, `USD`, `CAD`, `GBP`, `NZD` or `EUR`. The currency must be enabled on your Authorize.Net account.	Yes	`empty string`	No
Amount - total to pay	The total to collect, as a plain number with a dot for decimals and no currency symbol, for example `125.00` or `[InvoiceTotal]`.	Yes	`empty string`	Yes
Bank Aba Code	The routing (ABA) number of the customer's bank.	Yes	`empty string`	Yes
Bank Acct Num	The customer's bank account number.	Yes	`empty string`	Yes
Bank Acct Type	The account type: `CHECKING`, `BUSINESSCHECKING` or `SAVINGS`.	Yes	`empty string`	Yes
Bank Name	The name of the customer's bank.	Yes	`empty string`	No
Bank Acct Name	The name on the bank account.	Yes	`empty string`	Yes
eCheck Type	How the payment was authorized. See eCheck types.	Yes	`empty string`	Yes
Bank Check Number	The number of the customer's paper check. Only needed for the `ARC` and `BOC` eCheck types.	Yes	`empty string`	No
First Name	The customer's first name.	Yes	`empty string`	No
Last Name	The customer's last name.	Yes	`empty string`	No
Address	The customer's street address.	Yes	`empty string`	No
City	The customer's city.	Yes	`empty string`	No
State	The customer's state or province.	Yes	`empty string`	No
Country	The customer's country.	Yes	`empty string`	No
Postal Code	The customer's ZIP or postal code.	Yes	`empty string`	No
Fields	Extra Authorize.Net fields to send. Each row has an Authorize.Net Field name, for example `x_invoice_num` or `x_email`, and a Value. Names and values can contain tokens. You can't repeat a field that the action already sends, such as `x_amount` or `x_bank_acct_num`. A duplicate name makes the action fail with an error.	Yes	None	No
On Approved	Actions to run when the payment is approved (response code `1`).	No	None	No
On Declined	Actions to run when the payment is declined (response code `2`).	No	None	No
On Error	Actions to run when Authorize.Net returns an error (response code `3`), for example for invalid credentials or a bad routing number.	No	None	No
On Held For Review	Actions to run when the payment is held for review (response code `4`).	No	None	No

Which fields are really required depends on the eCheck type and your Authorize.Net account settings. The gateway rejects the payment, and On Error runs, if a field it needs is missing.

`Output Parameters Reference`

Type a name without brackets, for example AnetTransactionId, and use it later as [AnetTransactionId]. The tokens are set before the On Approved, On Declined, On Error or On Held For Review actions run, so you can use them there.

Parameter	Description
Output Authorize.Net Response Code Token Name	The response code: `1` approved, `2` declined, `3` error, `4` held for review.
Output Authorize.Net Response Reason Code Token Name	The Authorize.Net reason code, which explains the response in more detail.
Output Authorize.Net Response Reason Text Token Name	The reason as text, for example `This transaction has been approved.`
Output Authorize.Net Response Authorization Code Token Name	The authorization code. It's only set when Authorize.Net returns one.
Output Authorize.Net Response Transaction ID Token Name	The transaction ID that Authorize.Net assigned. Save it if you may need to refund or look up the payment later.

`eCheck types`

The eCheck type tells the bank how the customer authorized the payment. Pick the one that matches how you collect the bank details.

Type	Use it when
`WEB`	The customer enters their bank details online, for example in a form.
`TEL`	The customer authorizes the payment over the phone.
`PPD`	The customer signed an authorization, for example for regular payments from a personal account.
`CCD`	The payment is from a business account.
`ARC`	You convert a paper check received by mail. Needs Bank Check Number.
`BOC`	You convert a paper check in your back office. Needs Bank Check Number.

Each type has its own authorization rules. Check the Authorize.Net eCheck guide before you go live.

`Considerations`

Bank data passes through your server. The routing and account numbers are read from the form or tokens on your server and sent to Authorize.Net over TLS 1.2. Don't save full account numbers in your database, logs, emails or saved form state.
Approved isn't the same as paid. eCheck payments take a few days to clear, and a payment that was approved can still be returned by the bank later. Check its status in Authorize.Net before you ship goods that can't be recovered.
Test with the sandbox first. With Go Live off, payments go to the Authorize.Net sandbox, which only accepts sandbox account credentials. Turn Go Live on, with your production API Login ID and Transaction Key, only when you're ready to take real payments.
The actions after it always run. A declined or failed payment doesn't stop execution by itself. Put the actions that should only happen after a payment in On Approved. End On Declined and On Error with an action that ends execution, such as Display Error Message, if nothing else should run.
Connection problems aren't handled by On Error. If Authorize.Net can't be reached, the action fails with an exception that starts with Error:. To handle it, put the action inside Execute Actions and use its On Error.
Form templates. In Forms, the Pay With eCheck WEB, Pay With eCheck TEL, Pay With eCheck PPD and Pay With eCheck ARC templates (all ending in , Authorize.Net) give you a form that already has the bank and billing fields.

`Examples`

tip

To understand how to use the below examples, please see Running Examples.

`1. Pay an invoice from a bank account`

This action collects an invoice total on a form's submit, in the sandbox. The bank and billing parameters point to the form fields with those names. The API Login ID and Transaction Key come from the AnetLoginId and AnetTransactionKey tokens. On approval, the transaction ID is shown to the user. A declined or failed payment shows the reason and ends execution.

{
    "Title": "Make a payment with Electronic Check",
    "ActionType": "Pay with Electronic Check",
    "Description": "Collect the invoice total by eCheck",
    "Parameters": {
        "AuthorizeNetAPILoginID": "[AnetLoginId]",
        "AuthorizeNetTransactionKey": "[AnetTransactionKey]",
        "AuthorizeNetTransactionType": "AUTH_CAPTURE",
        "AuthorizeNetLiveMode": false,
        "AuthorizeNetTitle": "Invoice [InvoiceId]",
        "AuthorizeNetCurrency": "USD",
        "AuthorizeNetAmount": "[InvoiceTotal]",
        "AuthorizeNetBankAbaCode": "RoutingNumber",
        "AuthorizeNetBankAcctNum": "AccountNumber",
        "AuthorizeNetBankAcctType": "AccountType",
        "AuthorizeNetBankName": "BankName",
        "AuthorizeNetBankAcctName": "NameOnAccount",
        "AuthorizeNetECheckType": "WEB",
        "AuthorizeNetFirstName": "FirstName",
        "AuthorizeNetLastName": "LastName",
        "AuthorizeNetAddress": "Address",
        "AuthorizeNetCity": "City",
        "AuthorizeNetState": "State",
        "AuthorizeNetCountry": "Country",
        "AuthorizeNetPostalCode": "PostalCode",
        "AuthorizeNetFields": [
            {
                "name": "x_invoice_num",
                "value": "[InvoiceId]"
            }
        ],
        "AuthorizeNetResponseCodeTokenName": "AnetResponseCode",
        "AuthorizeNetResponseReasonTextTokenName": "AnetReasonText",
        "AuthorizeNetResponseTransactionIDTokenName": "AnetTransactionId",
        "OnApproved": [
            {
                "Title": "Display Message",
                "ActionType": "ShowMessage",
                "Parameters": {
                    "Message": "<p>Thank you! Your payment was accepted. Transaction ID: [AnetTransactionId]</p>"
                }
            }
        ],
        "OnDeclined": [
            {
                "Title": "Display Error Message",
                "ActionType": "ShowError",
                "Parameters": {
                    "Message": "<p>Your payment was declined: [AnetReasonText]</p>"
                }
            }
        ],
        "OnError": [
            {
                "Title": "Display Error Message",
                "ActionType": "ShowError",
                "Parameters": {
                    "Message": "<p>We couldn't process your payment: [AnetReasonText]</p>"
                }
            }
        ]
    }
}

Revised 09/27/2026

Typical Use Cases​

Don't use it to​

Related Actions​

Input Parameter Reference​

Output Parameters Reference​

eCheck types​

Considerations​

Examples​

1. Pay an invoice from a bank account​