Mattering Automations Authorize.Net integration
Connect Authorize.Net to Mattering Automations: card and bank transactions, voids and refunds, settlement reporting, stored customer payment profiles and recurring billing as workflow steps, authenticated with an API Login ID and Transaction Key that default to the sandbox environment.
The Mattering Automations Authorize.Net integration puts 43 gateway operations on your automation canvas: charge, authorize, capture, void and refund card transactions, debit and credit bank accounts, read transaction details, settled batches and batch statistics, store and reuse customer payment profiles and shipping addresses, and run Automated Recurring Billing subscriptions.
This connector moves real money, so read the three warnings in this guide before you build with it rather than after. A failed transaction is not an HTTP error on this API. Amounts are decimal dollars, not cents. And there is no idempotency key, so a retried run can charge twice unless you configure the vendor's duplicate window. Each of those has its own section below, and every affected node repeats the rule in its own description.
The credential is an API Login ID and a Transaction Key from the Merchant Interface, plus the environment. Authorize.Net has no authorization header and no bearer token: credentials travel inside the request body, which the connector assembles for you. Sandbox and production are separate hosts with separate accounts, and nothing in an API Login ID says which one it belongs to, so the environment lives on the credential and defaults to sandbox. A free sandbox account needs no card and no merchant application, which means the whole catalog, including the money-moving half, can be exercised properly before anything real is connected.
Before you start
- An Authorize.Net account. For a first build, use a sandbox account from the vendor's developer sandbox signup: it issues its own API Login ID and Transaction Key, and asks for no card, no merchant application and no production account.
- Access to API Credentials and Keys in the Merchant Interface, under Account. The API Login ID is shown there, and the Transaction Key is displayed once when you generate it.
- A decision about which environment this credential is for. Sandbox and production are different hosts and different accounts, so a production workflow needs its own credential rather than a setting change, and mixing them is not possible by accident on a node.
- For anything beyond reporting, a clear picture of who or what is allowed to trigger a payment. Eighteen of the 43 nodes are flagged destructive, and the flag exists so the destructive half can be gated behind a condition or an approval step rather than run from a bare trigger.
- A Mattering workspace with access to the Automations app.
- Not required and not recommended: putting raw card numbers into a workflow. The stored-profile path exists so the automation never has to carry one, and the card-present family that would carry full track data is not built at all.
Get your API Login ID and Transaction Key
Authorize.Net authenticates with a merchant authentication block inside the request body rather than with a header, so there is no bearer token to mint and no scopes to choose. Two values identify you, and both come from the same screen in the Merchant Interface. Generate them in the account you actually intend to automate, and start with a sandbox account unless you have a specific reason not to.
Connect Authorize.Net to Mattering
Verify it works
Open any automation canvas and check the palette for an Authorize.Net section listing the read and action nodes. Drop Authorize.Net: Test Authentication onto the canvas and run a test step. It takes no parameters and touches nothing. In the output, look at data.messages.resultCode: Ok means the credential is good, and Error with code E00007 means it is not, even though the step itself reports a successful HTTP call. Getting used to reading that field here is the point of doing this first, because every other node on this connector behaves the same way.
Next run Authorize.Net: Get Merchant Details. It confirms which account you are actually talking to, including the gateway id, the currencies and card types enabled, and the processors behind it, which is the fastest way to catch a sandbox credential in a workflow you thought was production or the reverse. One field there is worth handling carefully: the public client key is designed to be embedded in a payment form and cannot charge anything on its own, but it does identify the account, so do not forward it casually.
Then run Authorize.Net: List Settled Batches over a recent date window. On a new sandbox account it will legitimately return nothing, which is still a pass. Everything in this verify path is read-only and cannot reach any of the 18 destructive nodes, so it is safe to re-run whenever you rotate the Transaction Key.
Node reference
43 nodes, generated from the connector itself so this reference always matches what ships.
Read and query nodes 16
Authorize.Net: Get Batch Statistics
authorize_net_get_batch_statistics
Totals for one settlement batch, broken down by account type: charge and refund amounts and counts, voids, declines, errors, chargebacks, correction notices and returned items. This is the reconciliation node - it is what a daily "what settled yesterday" automation reads. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Get Customer Payment Profile
authorize_net_get_customer_payment_profile
Read one stored payment profile: the masked instrument (XXXX1111 and an expiration date of XXXX), the card type, the billing address, and the original network transaction id used for stored-credential compliance. Nothing here can reconstruct the card. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Get Customer Profile
authorize_net_get_customer_profile
Read one stored customer profile with all of its payment profiles and shipping addresses, plus the ids of any subscriptions billing it. Look up by profile id, or by your own merchantCustomerId, or by email - send exactly one. Card numbers come back masked (XXXX1111) and expiration dates as XXXX; this node deliberately does not expose the unmaskExpirationDate flag. This is the source node for the payment-profile and shipping-address pickers. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Get Customer Shipping Address
authorize_net_get_customer_shipping_address
Read one stored shipping address from a customer profile, along with the ids of any subscriptions shipping to it. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Get Merchant Details
authorize_net_get_merchant_details
Account configuration: gateway id, merchant name, the processor behind the account, which card brands and currencies are enabled, market types, and whether the account is in test mode. Useful as a preflight - isTestMode false on what you believed was a sandbox credential means the next charge is real. NOTE the response also contains publicClientKey, the Accept.js key. It is designed to be embedded in a public payment form and cannot charge anything on its own, so it is returned rather than redacted, but it is account-identifying material and should not be forwarded into logs or chat without thought. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Get Subscription
authorize_net_get_subscription
Read one subscription: name, schedule, amount and trial amount, status, the customer profile and masked instrument behind it, and optionally the list of payments it has already attempted with the gateway's response to each. The transaction history is what a dunning automation reads to spot a failed payment. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Get Subscription Status
authorize_net_get_subscription_status
Read just the status of one subscription: active, expired, suspended, canceled or terminated. suspended is the one that matters operationally - it means a payment failed and the gateway has stopped trying, so a dunning workflow branches on it. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Get Transaction Details
authorize_net_get_transaction_details
Full detail for one transaction: type, status, amounts requested/authorized/settled, the settlement batch, the fraud filters that fired, order and line items, the masked payment instrument, and the customer profile it came from. This is the node that answers "did that charge actually go through" - transactionStatus tells you where it is in the settlement lifecycle, which a create call cannot. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: List Customer Payment Profiles
authorize_net_list_customer_payment_profiles
List stored payment profiles ACROSS ALL customer profiles that expire in a given month. Read the shape of this one before reaching for it: the vendor supports exactly one search type, cardsExpiringInMonth, so it is a card-expiry report rather than a general lister - it cannot list the payment profiles of one customer, which is what Authorize.Net: Get Customer Profile does. Its natural use is the dunning workflow: find cards expiring next month and email those customers. Pages 1000 rows at a time. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: List Customer Profile IDs
authorize_net_list_customer_profile_ids
Every customer profile id on the account, as a flat array of strings. This is the vendor's ONLY profile lister and it returns ids with no names, emails or anything else attached, so pair it with Authorize.Net: Get Customer Profile when you need detail. It also does not page or filter, so a large account returns a large array in one response. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: List Settled Batches
authorize_net_list_settled_batches
List settlement batches in a date window, optionally with per-batch statistics (charge and refund counts and amounts, declines, errors, chargebacks, returned items). Batch ids from here are what Authorize.Net: List Transactions and Authorize.Net: Get Batch Statistics take. This endpoint does NOT page: it windows on settlement date instead, and the vendor's own guidance is to keep the window short. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: List Subscriptions
authorize_net_list_subscriptions
List subscriptions by one of the vendor's four fixed search types: subscriptionActive, subscriptionInactive, subscriptionExpiringThisMonth, or cardExpiringThisMonth. There is no free-text search and no date range - the search type IS the filter. Returns id, name, status, customer name, masked account, amount, and how many occurrences have already run. Pages 1000 rows at a time. This is the source node for the subscription picker. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: List Transactions
authorize_net_list_transactions
List transactions in a settlement batch: id, submit time, status, customer name, masked account, settled amount, and the subscription or customer profile behind each one. This is the settled side of reporting; use Authorize.Net: List Unsettled Transactions for anything from today that has not been batched yet. Pages 1000 rows at a time, and offset is a page number starting at 1. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: List Transactions For Customer
authorize_net_list_transactions_for_customer
Every transaction belonging to one stored customer profile, optionally narrowed to a single payment profile. Same row shape as Authorize.Net: List Transactions. Useful for answering "what has this customer paid us" without walking settlement batches. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: List Unsettled Transactions
authorize_net_list_unsettled_transactions
List transactions that have not settled yet - everything still voidable, plus anything the Advanced Fraud Detection Suite is holding. Set status to pendingApproval to get ONLY the held queue, which is what the vendor documents separately as Get Held Transaction List; there is no separate operation for it. This lister is the source for the transaction pickers on Void, Capture Prior Authorization and Approve or Decline Held Transaction, because those calls are legal only against unsettled transactions. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Test Authentication
authorize_net_authenticate_test
Check that the stored API Login ID and Transaction Key are valid against the environment the credential names (sandbox or production). Reads nothing and writes nothing, which makes it the cheapest possible probe. Note that a WRONG credential also returns HTTP 200: a failure comes back as data.messages.resultCode "Error" with code E00007, "User authentication failed due to invalid authentication values". A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Action nodes 27
Authorize.Net: Approve or Decline Held Transaction
authorize_net_update_held_transaction
DESTRUCTIVE AND TERMINAL EITHER WAY. Resolves a transaction the Advanced Fraud Detection Suite put on hold. action "approve" releases it for settlement, which MOVES REAL MONEY exactly as the original charge would have; action "decline" kills it permanently. What is irreversible: both outcomes. An approved transaction can then only be voided (before settlement) or refunded (after), and a declined one cannot be revived - collecting that money means charging the customer again from scratch. Find held transactions with Authorize.Net: List Unsettled Transactions with status pendingApproval. A DECLINE is not an HTTP error. This call returns HTTP 200 whatever happens, so the node envelope reads success true even when no money moved. Branch on BOTH data.messages.resultCode ("Ok" or "Error") and data.transactionResponse.responseCode: "1" approved, "2" declined, "3" error, "4" held for review. The reason for a decline is in data.transactionResponse.errors[].errorText, not in the outer messages.
Authorize.Net: Authorize Credit Card
authorize_net_authorize_credit_card
DESTRUCTIVE - THIS HOLDS REAL MONEY. Places an authorization hold on a card without capturing it (transactionType authOnlyTransaction). No money settles yet, but the amount is deducted from the cardholder's available credit immediately and stays deducted until the hold is captured, voided, or expires - the vendor allows capture for up to 30 days. What is irreversible: nothing here, which is the whole point of using it. The reversal path is Void Transaction, which releases the hold; Capture Prior Auth is the other exit and it does move the money. Abandoning a hold instead of voiding it leaves a customer's funds tied up for weeks, so treat that as a bug rather than a no-op. A DECLINE is not an HTTP error. This call returns HTTP 200 whatever happens, so the node envelope reads success true even when no money moved. Branch on BOTH data.messages.resultCode ("Ok" or "Error") and data.transactionResponse.responseCode: "1" approved, "2" declined, "3" error, "4" held for review. The reason for a decline is in data.transactionResponse.errors[].errorText, not in the outer messages.
Authorize.Net: Authorize Customer Profile
authorize_net_authorize_customer_profile
DESTRUCTIVE - THIS HOLDS REAL MONEY. Places an authorization hold on a stored customer payment profile without capturing it (transactionType authOnlyTransaction with a profile element). No money settles, but the amount is deducted from the cardholder's available credit and stays deducted until captured, voided or expired - up to 30 days. The reversal path is Void Transaction, which releases the hold; Capture Prior Authorization is the other exit and it does move the money. A DECLINE is not an HTTP error. This call returns HTTP 200 whatever happens, so the node envelope reads success true even when no money moved. Branch on BOTH data.messages.resultCode ("Ok" or "Error") and data.transactionResponse.responseCode: "1" approved, "2" declined, "3" error, "4" held for review. The reason for a decline is in data.transactionResponse.errors[].errorText, not in the outer messages.
Authorize.Net: Cancel Subscription
authorize_net_cancel_subscription
DESTRUCTIVE AND TERMINAL. Cancels a recurring billing subscription. Future charges stop. What is irreversible: the cancellation itself - the vendor documents no reactivate call, so resuming billing means creating a NEW subscription, which needs the card or stored payment profile again and starts a fresh schedule. What this does NOT do: it does not refund anything. Every payment already collected stays collected, and giving it back means a separate Refund Transaction per payment. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Capture Only
authorize_net_capture_only
DESTRUCTIVE - THIS MOVES REAL MONEY. Settles funds against an authorization code obtained OUTSIDE the gateway, such as a voice authorization taken over the phone (transactionType captureOnlyTransaction). The card is charged and the amount is queued for settlement. What is irreversible: the capture. Void Transaction reverses it before the batch settles; Refund Transaction is the only route afterwards and is a second money movement, not an undo. This node is easy to misuse: if the authorization came from Authorize Credit Card you want Capture Prior Authorization instead, because capturing the same authorization twice by two different routes charges the customer twice. A DECLINE is not an HTTP error. This call returns HTTP 200 whatever happens, so the node envelope reads success true even when no money moved. Branch on BOTH data.messages.resultCode ("Ok" or "Error") and data.transactionResponse.responseCode: "1" approved, "2" declined, "3" error, "4" held for review. The reason for a decline is in data.transactionResponse.errors[].errorText, not in the outer messages.
Authorize.Net: Capture Prior Authorization
authorize_net_capture_prior_auth
DESTRUCTIVE - THIS MOVES REAL MONEY. Captures a hold placed earlier by Authorize Credit Card (transactionType priorAuthCaptureTransaction) and queues it for settlement, so the funds leave the cardholder. What is irreversible: the capture itself. Before the nightly batch settles, Void Transaction reverses it; after settlement the only route is Refund Transaction, which is a second money movement rather than an undo. Leaving the amount blank captures the full authorized amount; a smaller amount captures part of the hold and releases the rest. Authorizations expire after 30 days and cannot be captured afterwards. A DECLINE is not an HTTP error. This call returns HTTP 200 whatever happens, so the node envelope reads success true even when no money moved. Branch on BOTH data.messages.resultCode ("Ok" or "Error") and data.transactionResponse.responseCode: "1" approved, "2" declined, "3" error, "4" held for review. The reason for a decline is in data.transactionResponse.errors[].errorText, not in the outer messages.
Authorize.Net: Charge Credit Card
authorize_net_charge_credit_card
DESTRUCTIVE - THIS MOVES REAL MONEY. Authorizes AND captures a card in one call (transactionType authCaptureTransaction): the amount is charged to the cardholder and queued for the next settlement batch. What is irreversible: nothing un-does a charge. Before the batch settles the reversal is Void Transaction, which cancels it cleanly and returns the held funds. After it settles the only route is Refund Transaction, and a refund is a SECOND movement of money in the other direction, not an undo - it appears as its own transaction, carries its own fees, and can itself fail. Use Authorize Credit Card instead if you want a hold you can release. There is no idempotency key on this API, so set transaction_settings {"duplicateWindow": "120"} if a retried run must not charge twice. A DECLINE is not an HTTP error. This call returns HTTP 200 whatever happens, so the node envelope reads success true even when no money moved. Branch on BOTH data.messages.resultCode ("Ok" or "Error") and data.transactionResponse.responseCode: "1" approved, "2" declined, "3" error, "4" held for review. The reason for a decline is in data.transactionResponse.errors[].errorText, not in the outer messages.
Authorize.Net: Charge Customer Profile
authorize_net_charge_customer_profile
DESTRUCTIVE - THIS MOVES REAL MONEY. Charges a card or bank account already stored as a customer payment profile (transactionType authCaptureTransaction with a profile element), so nothing stands between this call and a real charge: the customer authorized the instrument earlier and is not asked again. What is irreversible: nothing un-does a charge. Void Transaction reverses it before the nightly batch settles; Refund Transaction is the only route afterwards and is a second money movement, not an undo. There is no idempotency key on this API, so set transaction_settings {"duplicateWindow": "120"} if a retried run must not charge twice. A DECLINE is not an HTTP error. This call returns HTTP 200 whatever happens, so the node envelope reads success true even when no money moved. Branch on BOTH data.messages.resultCode ("Ok" or "Error") and data.transactionResponse.responseCode: "1" approved, "2" declined, "3" error, "4" held for review. The reason for a decline is in data.transactionResponse.errors[].errorText, not in the outer messages.
Authorize.Net: Create Customer Payment Profile
authorize_net_create_customer_payment_profile
Store a card or bank account against an existing customer profile. Moves no money; the inverse is Authorize.Net: Delete Customer Payment Profile. Send EITHER the card fields OR the bank account fields, never both. Read Validation Mode first: the default (testMode) contacts nobody, liveMode runs a real 0.00 authorization against the cardholder's account. Once stored, this instrument can be charged by Charge Customer Profile and by subscriptions with no further approval from the customer. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Create Customer Profile
authorize_net_create_customer_profile
Create a stored customer profile, optionally with its first payment profile in the same call. Moves no money; the inverse is Authorize.Net: Delete Customer Profile. Read the Validation Mode field before running this against a real card: the default (testMode) contacts nobody, while liveMode runs a real 0.00 authorization against the cardholder's account. A profile created here is what Charge Customer Profile and the subscription nodes bill later, with no further approval from the customer, so treat storing an instrument as the consequential step it is. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Create Customer Profile From Transaction
authorize_net_create_profile_from_transaction
Turn a transaction that already happened into a stored customer profile, using the payment data the gateway already holds for it. This is how a card gets stored WITHOUT the card number ever passing through this automation - the cleanest path there is. Moves no money; the inverse is Authorize.Net: Delete Customer Profile. Give an existing customerProfileId to attach the transaction's instrument to that customer instead of creating a new one. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Create Customer Shipping Address
authorize_net_create_customer_shipping_address
Add a shipping address to a stored customer profile. Moves no money and stores no payment data; the inverse is Authorize.Net: Delete Customer Shipping Address. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Create Subscription
authorize_net_create_subscription
DESTRUCTIVE - THIS SCHEDULES REAL, REPEATING CHARGES. Creates an Automated Recurring Billing subscription against a card supplied here. Nothing stands between this call and money moving except the start date: no approval step, no confirmation, and the first charge lands on startDate, which can be today. What is irreversible: every payment the schedule has already taken. Cancel Subscription stops FUTURE charges only, the vendor documents no way to reactivate a cancelled subscription, and refunding what was already collected is a separate second money movement per payment. A subscription is also the easiest object here to duplicate by accident - there is no idempotency key, so a retried run creates a SECOND subscription billing the same customer. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Create Subscription From Customer Profile
authorize_net_create_subscription_from_profile
DESTRUCTIVE - THIS SCHEDULES REAL, REPEATING CHARGES against a card the customer stored EARLIER. Same operation as Authorize.Net: Create Subscription, but billing an existing customer payment profile instead of a card typed here, so no cardholder data passes through the automation. That also means there is no second approval anywhere in the loop: the customer authorized the instrument at some point in the past, and this call starts charging it. What is irreversible: every payment already taken. Cancel Subscription stops future charges only and cannot be reactivated; refunds are separate money movements. A retried run creates a SECOND subscription on the same customer - there is no idempotency key. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Credit Bank Account
authorize_net_credit_bank_account
DESTRUCTIVE - THIS SENDS REAL MONEY TO A BANK ACCOUNT. Refunds a settled eCheck.Net debit (transactionType refundTransaction with a bankAccount). What is irreversible: an ACH credit is a second money movement, not an undo, and once it is in flight it cannot be recalled through this API - Void Transaction only works before the batch settles. Getting the destination account digits wrong sends money to someone else, and this node has no way to know that. A DECLINE is not an HTTP error. This call returns HTTP 200 whatever happens, so the node envelope reads success true even when no money moved. Branch on BOTH data.messages.resultCode ("Ok" or "Error") and data.transactionResponse.responseCode: "1" approved, "2" declined, "3" error, "4" held for review. The reason for a decline is in data.transactionResponse.errors[].errorText, not in the outer messages.
Authorize.Net: Debit Bank Account
authorize_net_debit_bank_account
DESTRUCTIVE - THIS DEBITS A REAL BANK ACCOUNT. Runs an eCheck.Net ACH debit (transactionType authCaptureTransaction with a bankAccount instead of a card) and requires eCheck.Net to be enabled on the merchant account. What is irreversible: an ACH debit is slower and less reversible than a card charge. Void Transaction works only before the batch settles; after that the reversal is Credit Bank Account, a second ACH movement that takes days to clear and can itself be returned. The bank can also return the debit days later (insufficient funds, closed account), which arrives as a returned item in reporting rather than as an error on this call. You must have the account holder's authorization for the echeckType you send. A DECLINE is not an HTTP error. This call returns HTTP 200 whatever happens, so the node envelope reads success true even when no money moved. Branch on BOTH data.messages.resultCode ("Ok" or "Error") and data.transactionResponse.responseCode: "1" approved, "2" declined, "3" error, "4" held for review. The reason for a decline is in data.transactionResponse.errors[].errorText, not in the outer messages.
Authorize.Net: Delete Customer Payment Profile
authorize_net_delete_customer_payment_profile
DESTRUCTIVE AND PERMANENT. Deletes a stored card or bank account from a customer profile. The instrument is gone: it can no longer be charged, and it cannot be restored - putting it back means collecting the customer's card details again, which is exactly the step storing it was meant to avoid. Anything pointing at this payment profile (saved-card checkouts, subscriptions billing it) breaks. No money moves and past transactions are untouched. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Delete Customer Profile
authorize_net_delete_customer_profile
DESTRUCTIVE AND PERMANENT. Deletes a stored customer profile and, with it, EVERY payment profile and shipping address underneath it. The stored cards and bank accounts are gone and cannot be restored - re-creating the profile means collecting the customer's card details again, which is the part that cannot be automated. Anything still pointing at those payment profiles (saved-card checkouts, scheduled charges) breaks. No money moves and settled transaction history is not deleted; only the stored instruments are. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Delete Customer Shipping Address
authorize_net_delete_customer_shipping_address
DESTRUCTIVE AND PERMANENT. Deletes a stored shipping address from a customer profile. It moves no money and destroys no payment data, but there is no undelete and no archive: restoring it means re-entering the address. Subscriptions shipping to it lose their destination. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Refund Transaction
authorize_net_refund_transaction
DESTRUCTIVE - THIS MOVES REAL MONEY, OUT. Refunds a SETTLED card transaction (transactionType refundTransaction). What is irreversible: everything about it. A refund is not an undo - it is a brand new transaction in the opposite direction, with its own id, its own settlement, and its own fees, and the original charge stays on the customer's statement beside it. There is no un-refund endpoint; the only reversal is voiding the REFUND itself before it settles, using Void Transaction on the refund's transId. If the original transaction has not settled yet, do not use this node at all: void it instead, which is cleaner and cheaper. Note the vendor's odd requirement, which is not a typo: alongside the original transaction id you must send the LAST FOUR DIGITS of the card and the literal string XXXX as the expiration date. A DECLINE is not an HTTP error. This call returns HTTP 200 whatever happens, so the node envelope reads success true even when no money moved. Branch on BOTH data.messages.resultCode ("Ok" or "Error") and data.transactionResponse.responseCode: "1" approved, "2" declined, "3" error, "4" held for review. The reason for a decline is in data.transactionResponse.errors[].errorText, not in the outer messages.
Authorize.Net: Send Customer Transaction Receipt
authorize_net_send_customer_receipt
DESTRUCTIVE - THIS EMAILS A REAL PERSON. Sends the Authorize.Net receipt for an existing transaction to the email address given. No money moves, but the message cannot be unsent and it goes out under the merchant's name, so a loop or a wrong address is a customer-facing incident rather than a failed API call. Sending to an address that was not the payer's discloses that transaction to whoever receives it. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Update Customer Payment Profile
authorize_net_update_customer_payment_profile
Update a stored payment profile - typically a new expiration date or a corrected billing address. Moves no money. The trap here is the vendor's REPLACE semantics on the payment element: this call overwrites the whole stored instrument, so you must send the FULL card number again, not the masked XXXX1111 you read back from Get Customer Payment Profile. Sending the masked value stores the mask, and the instrument stops being chargeable. Same for the billing address: fields you omit are cleared. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Update Customer Profile
authorize_net_update_customer_profile
Update the top-level fields of a stored customer profile: your own customer id, the description, and the email. Moves no money and touches no stored card. Note the vendor's replace semantics: a field you leave blank is CLEARED on the profile rather than left alone, so send the current values for anything you are not deliberately changing. Payment instruments are edited with Authorize.Net: Update Customer Payment Profile, not here. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Update Customer Shipping Address
authorize_net_update_customer_shipping_address
Update a stored shipping address. Moves no money. Replace semantics again: the address object overwrites the stored one, so send every field you want to keep. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Update Subscription
authorize_net_update_subscription
Update a live subscription: the amount, the stored card, the billing address, or the remaining schedule. No money moves at the moment of the call and every change can be changed back, which is why this is a reversible write - but it decides what a real customer is charged on the NEXT run, so raising the amount here is a price change, not an edit. The vendor's constraints: the interval (length and unit) cannot be changed after creation, and the start date cannot be changed once the first payment has been taken. Send only the fields you are changing. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Validate Customer Payment Profile
authorize_net_validate_customer_payment_profile
Check that a stored payment profile is still good, by having the gateway generate a test transaction against it. Nothing is captured and no money moves, so this is classed a reversible write rather than a money movement - but it is NOT free of consequences at every setting. Validation Mode is REQUIRED here and defaults to testMode, which contacts nobody. liveMode sends a real 0.00 authorization to the cardholder's bank (0.01 where 0.00 is unsupported) and immediately voids it, which can surface as a pending line on the customer's statement; oldLiveMode always uses 0.01 and the vendor's own schema warns it can result in fines from your processor. The result arrives as a legacy comma-separated directResponse string, not as a JSON object. A FAILED call still returns HTTP 200, so this node's envelope reads success true either way: branch on data.messages.resultCode ("Ok" or "Error") and read data.messages.message[].code (I00001 on success, an E-code such as E00027 on failure).
Authorize.Net: Void Transaction
authorize_net_void_transaction
DESTRUCTIVE AND TERMINAL. Cancels a transaction that has not settled yet (transactionType voidTransaction): the hold is released and the transaction will never settle. This is the clean reversal for a charge, an authorization or a capture made TODAY, before the nightly batch runs - it moves no money and usually leaves nothing on the cardholder's statement. What is irreversible: the void itself. There is no un-void; a voided transaction can never be settled, and collecting that money means creating a NEW charge. Once the batch has settled, a void is no longer legal and Refund Transaction is the only path. A DECLINE is not an HTTP error. This call returns HTTP 200 whatever happens, so the node envelope reads success true even when no money moved. Branch on BOTH data.messages.resultCode ("Ok" or "Error") and data.transactionResponse.responseCode: "1" approved, "2" declined, "3" error, "4" held for review. The reason for a decline is in data.transactionResponse.errors[].errorText, not in the outer messages.
Using the integration
A decline is not an HTTP error
This is the rule to internalise before building anything. Authorize.Net answers HTTP 200 for a successful charge, a declined charge, a malformed request and an invalid credential alike, so the node's success flag reports that the CALL worked, never that money moved. Two levels have to be read. The outer level is data.messages.resultCode, which is Ok or Error, with a message code alongside it where an I prefix is informational and an E prefix is an error. The inner level, on transaction nodes, is data.transactionResponse.responseCode: 1 approved, 2 declined, 3 error, 4 held for review, with the human-readable reason in data.transactionResponse.errors rather than in the outer messages. They disagree on purpose. A decline arrives as an outer Error with an inner 2 or 3. A held-for-review transaction can arrive as an outer Ok with an inner 4. Read only the outer and you misclassify holds; read only the inner and you miss malformed requests, which carry no transaction response at all. Branch on both, in that order, in every workflow that charges anything. The connector deliberately does not fold this into the success flag, because deciding what held for review means for your business is not a decision a connector should make for you.
Amounts are decimal dollars, not cents
An amount of 5.00 is five dollars, and so is 5. Several other payment platforms take an integer count of the smallest unit, where five dollars is 500, so if you are porting a workflow or a habit from one of those, this is a hundredfold error waiting in the direction that overcharges a real person. Every money field says the unit in the same words for exactly that reason, since the configuration panel is the last place a human sees the number before it becomes a charge. Amounts are sent as strings so the value you typed is the value that goes on the wire, with no floating point rounding in between, and the vendor supports four decimal places. The currencies the vendor lists are USD, CAD, GBP, DKK, NOK, PLN, SEK, EUR, AUD and NZD.
There is no idempotency key, so retries need a plan
Nothing on this API deduplicates a repeated request by a caller-supplied key. The vendor's substitute is duplicateWindow inside the transaction settings, a number of seconds during which an identical transaction is rejected as a duplicate instead of charged again, up to a documented maximum of 28800. Every transaction node that can be retried destructively exposes those settings, and any workflow that can run twice should set the window rather than assume the platform will not retry. Subscriptions are worse and need handling above the connector: they have no duplicate protection at all, so a retried create makes a SECOND subscription billing the same customer on the same schedule. If a public form or another retrying source can start a subscription, deduplicate before the node, not after.
Void before settlement, refund after, and they are not the same
Picking the wrong reversal costs money. Authorize.Net: Void Transaction cancels a transaction that has not settled yet: it moves no money, releases the hold, and usually leaves nothing on the cardholder's statement. It is also terminal, since a voided transaction can never settle and collecting that money later means creating a new charge. Authorize.Net: Refund Transaction applies once a transaction has settled, and it is a SECOND movement of money in the other direction rather than an undo. It gets its own transaction id, its own settlement and its own fees, the original charge stays on the customer's statement beside it, and there is no un-refund: the only reversal is voiding the refund itself before it settles. The refund node also has an unusual requirement that is not a typo, and it is stated on the node: alongside the original transaction id you send the last four digits of the card and the literal string XXXX as the expiration date. A reversal workflow should check whether the transaction has settled and branch, rather than reaching for one node for both cases.
Store cards without the number entering the workflow
Authorize.Net: Create Customer Profile From Transaction builds a stored customer profile from a payment that already happened, using the payment data the gateway already holds, which is the cleanest route to a reusable instrument because the full card number never passes through the automation. After that, Authorize.Net: Charge Customer Profile and Authorize.Net: Authorize Customer Profile bill it, Authorize.Net: Get Customer Profile reads its payment profiles and shipping addresses, and Authorize.Net: List Customer Profile IDs enumerates what exists. One field in this family deserves attention: the validation mode on the payment profile nodes decides what the gateway does to prove a card is real. Test mode contacts nobody and is the default here. Live mode places a real zero-value authorization against the cardholder's account. The older live mode always uses a small real amount and the vendor's own schema annotates it as not recommended because it can result in processor fines, so leave it alone unless you know exactly why you need it.
Recurring billing starts charging on its own
Authorize.Net: Create Subscription and Authorize.Net: Create Subscription From Customer Profile are flagged destructive for a reason that is easy to miss: nothing stands between the call and money moving except the start date, which can be today. There is no approval step and no confirmation, unlike some other subscription APIs where a buyer has to accept first. Authorize.Net: Update Subscription moves no money at call time and can be edited back, which is why it is not flagged, but raising the amount is a price change a real customer pays on the next run. Authorize.Net: Cancel Subscription stops FUTURE charges only: the vendor documents no way to reactivate a cancelled subscription, so resuming billing means creating a new one on a fresh schedule, and cancelling refunds nothing that was already collected. Refunding collected payments is a separate money movement per payment.
Reporting, paging and the settlement shape
The reporting family is where the safe, useful automations live. Authorize.Net: List Settled Batches windows on settlement date rather than paging, and the vendor advises keeping the window short. Authorize.Net: Get Batch Statistics returns the additive numbers for one batch, which is what a settlement dashboard actually needs, and Authorize.Net: List Transactions opens a batch row by row. Authorize.Net: List Unsettled Transactions covers everything from today that has not been batched, and it doubles as the held-for-review queue when its status filter is set to the pending approval value. Two paging rules apply to the listers that do page. The paging block's offset is a PAGE NUMBER starting at 1, not a row skip, so with a limit of 100, offset 2 is rows 101 to 200 and offset 0 is out of range. And paging and sorting are all-or-nothing pairs, so a partially filled pair is rejected with a readable error rather than sent for the vendor's schema validator to bounce.
From AI assistants over MCP
Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and Matter, the assistant built into the platform, can drive the same surface. On a payment gateway the sensible split is sharper than usual. The 16 read nodes make a genuinely useful assistant surface: reconcile a batch, explain a charge, check whether a subscription is active, find a customer's transactions. The 18 destructive nodes move money, reach a real person, or schedule repeating charges, and the flag exists so they can sit behind a condition or an approval task rather than behind an instruction in a prompt. Authorize.Net publishes no MCP server of its own: its GitHub organization holds a repository named for one, but it is empty, and neither the API reference nor the developer site mentions a server. That is a none found rather than a never, since the name has clearly been staked, so it is worth re-checking if it matters to your decision.
What the connector does with card data
Cardholder data flows one way and is masked on the way back. The gateway masks payment instruments in its own responses, so a stored card returns as its last four digits and a masked expiry, and this connector scrubs card-shaped values out of node output anyway, because node output lands in run logs, databases, chat messages and assistant context. Two values are deliberately left alone, with reasons. The public client key in Authorize.Net: Get Merchant Details is designed to be embedded in a public payment form and cannot charge anything on its own, so redacting it would break the node's main use, though it does identify the account. And the legacy direct-response strings carry customer details and the masked card rather than a full number, and they are the entire output of Authorize.Net: Validate Customer Payment Profile, so blanking them would leave that node returning nothing. On the request side, the card-present family carrying full track and chip data is not built at all. PCI stays your obligation, and the stored-profile path is the one that keeps the automation out of the worst of it.
Troubleshooting
Test Connection reports a successful call but the credential is wrong
A charge node reports success but no money moved
A customer was charged a hundred times too much
A retried workflow charged the customer twice
Refund Transaction fails on a transaction that clearly exists
A workflow is pointed at the wrong environment
A list node returns nothing or complains about paging
A request is rejected as malformed even though the values look right
A held-for-review transaction never appears in the reporting nodes
The customer profile picker shows raw ids instead of names
Related
The Authorize.Net MCP
What connecting Authorize.Net unlocks for AI agents and automations, with common uses and FAQs.
More guides
All Automations documentation
Every integration guide, plus how connectors, credentials, and workflows fit together.
Authorize.Net is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.