Menu

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.

Sign in to the Merchant Interface for the account you are connecting, or create a sandbox account from the vendor's developer sandbox signup if you are starting fresh.
Open Account and then API Credentials and Keys.
Copy the API Login ID shown on that page.
Generate a Transaction Key and copy it immediately.
The Transaction Key is shown once, at generation. If you leave the page without copying it you have to generate a new one, and generating a new key can break other integrations still using the old one.
A sandbox account is issued with its own separate API Login ID and Transaction Key. Sandbox credentials do not work against production and production credentials do not work against sandbox, which is a safety property rather than an inconvenience.

Connect Authorize.Net to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Authorize.Net from the list.
Click Create new credential, fill in API Login ID and Transaction Key, and leave Environment on sandbox for a first build.
Setting the environment to production points every node on that credential at a live ledger, where a mistake charges a real cardholder. Build and test on sandbox, then create a SECOND credential for production and switch the nodes over deliberately, one workflow at a time.
The Transaction Key is stored encrypted in Google Secret Manager, is registered for redaction on every run so it cannot appear in logs, and is scrubbed out of response payloads and transport errors by exact match.
Click Test Connection. Mattering calls the vendor's own authentication probe, which reads nothing and writes nothing.
Read the result, not the status code. This API returns HTTP 200 even for an invalid credential: a failure comes back as a result code of Error with the code E00007 and the text about invalid authentication values. That is the same pattern every other node on this connector follows.
Click Connect. All 43 Authorize.Net nodes appear in your canvas palette.

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
That is this API's normal behaviour rather than a bug in the check. Authorize.Net answers HTTP 200 even for invalid credentials, so the transport succeeded while the request failed. Read data.messages.resultCode in the output: Ok means the credential is good, Error with code E00007 and the text about invalid authentication values means the API Login ID or the Transaction Key is wrong. Check three things in this order. That both values came from the same account. That the Environment on the credential matches where those values were issued, since sandbox credentials do not work against production or the reverse. And that the Transaction Key has not been regenerated since you copied it, because generating a new one invalidates the old.
A charge node reports success but no money moved
The success flag reports the HTTP call, and this API returns 200 for declines too. Branch on both levels instead. First read data.messages.resultCode, which is Ok or Error for the request itself. Then read data.transactionResponse.responseCode: 1 approved, 2 declined, 3 error, 4 held for review. The reason for a decline is in data.transactionResponse.errors, not in the outer messages. A decline typically arrives as an outer Error with an E00027 code and an inner 2 or 3, while a held transaction can arrive as an outer Ok with an inner 4, which is why reading only one level misclassifies one of the two. If there is no transactionResponse in the output at all, the request itself was rejected, usually for a malformed or out-of-order body.
A customer was charged a hundred times too much
Almost certainly a unit mistake. Amounts on this API are decimal MAJOR units, so 5.00 is five dollars, while several other payment platforms take an integer count of the smallest unit where five dollars is 500. A value carried over from one of those conventions lands as five hundred dollars here. Check the field feeding the amount, and if it comes from another payment system or a stored integer, divide it in the step before the node rather than inside a template you will forget about. Reverse the transaction according to its stage: Authorize.Net: Void Transaction if the batch has not settled, Authorize.Net: Refund Transaction if it has.
A retried workflow charged the customer twice
There is no idempotency key on this API, so nothing deduplicates the second request on its own. The vendor's substitute is duplicateWindow inside the transaction settings, a number of seconds during which an identical transaction is rejected as a duplicate rather than charged again, with a documented maximum of 28800. Set it on any transaction node in a workflow that can retry. Then reverse the extra charge by stage: void it if it has not settled, refund it if it has. Subscriptions need different handling, because they have no duplicate protection at all: a retried create makes a second subscription, so deduplicate before the node and check Authorize.Net: List Subscriptions for an accidental twin.
Refund Transaction fails on a transaction that clearly exists
Three usual causes. The transaction has not settled yet, in which case a refund is not legal and Authorize.Net: Void Transaction is the correct node. The last four digits of the card and the expiration value are missing or wrong, since the vendor requires the last four digits alongside the transaction id and the literal string XXXX as the expiration date. Or the transaction id came from the wrong environment, since sandbox and production ids are not interchangeable. Note that the failure arrives as HTTP 200 with an error result code rather than as a 4xx, so read the messages block for the specific code before assuming the id is wrong.
A workflow is pointed at the wrong environment
The environment lives on the credential, not on the nodes, which is deliberate: a node-level switch would let one workflow send half its steps to a live ledger. So the fix is at the connection rather than in the canvas. Run Authorize.Net: Get Merchant Details to confirm which account a credential actually reaches, then create a separate credential for the other environment and reselect it on the nodes. An unrecognised environment value is rejected outright rather than falling back to a default, because a silent fallback toward production is the same accident with extra steps.
A list node returns nothing or complains about paging
Two rules cause most of this. The offset in the paging block is a PAGE NUMBER starting at 1, not a row skip, so offset 0 is out of range and with a limit of 100 the second page is offset 2. And paging and sorting are all-or-nothing pairs, so filling one half of either block is rejected. Also check you are using the right lister: Authorize.Net: List Transactions reads a settled batch and takes a batch id, Authorize.Net: List Unsettled Transactions covers today's unbatched activity, and Authorize.Net: List Settled Batches does not page at all, windowing on settlement date instead. The legal sort fields differ per lister, which is why an orderBy that works on subscriptions may be rejected on transactions.
A request is rejected as malformed even though the values look right
Element ORDER is part of the contract on this API. It offers JSON as a translation of an XML schema, and the vendor states that developers should force the order of elements to match the reference. The connector assembles every typed field in the required order for you, so this only bites where a workflow adds its own keys through the extra body field, which merges AFTER the typed fields and can therefore land a key in the wrong position. If you are using extra body, check the order against the vendor's reference for that operation, or move the value into a typed field where one exists.
A held-for-review transaction never appears in the reporting nodes
Held transactions are not a separate operation on this API despite the reference page's navigation suggesting one. They are unsettled transactions with a particular status, so read them with Authorize.Net: List Unsettled Transactions and set its status filter to the pending approval value. From there Authorize.Net: Approve or Decline Held Transaction acts on the decision. Be deliberate about automating that last step: approving releases real money, and declining kills the transaction permanently, with no route back other than charging again from scratch.
The customer profile picker shows raw ids instead of names
That is the vendor's payload rather than a broken path. The only profile lister on this API returns a bare array of id strings with nothing attached: no name, no email, nothing to label a row with. So the picker enumerates the real ids and falls back to showing the value, which is still better than an empty text box because the values are real and complete. The pickers that hang off a chosen profile are richer, because the profile read returns more: payment profiles show the masked card number grouped by card type with the cardholder's last name as a second line, and shipping addresses show the last name and the address. Refund and bank credit nodes deliberately have no transaction picker at all, because the only available source would list unsettled transactions, which are exactly the ones that should be voided rather than refunded.

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.

Start Free Explore our Products