An Authorize.Net MCP that treats money like money
Connect an API Login ID and Transaction Key and 43 nodes land on the canvas: charge, authorize, capture, void and refund, read settled batches and their statistics, store and reuse customer payment profiles, and run recurring billing. Eighteen of those nodes move real money, so they are flagged destructive, the credential defaults to sandbox, and every node tells you how to tell an approval from a decline.
What the Authorize.Net MCP connector does
The Authorize.Net connector for Mattering Automations is 43 nodes over the gateway's API: 12 payment transaction nodes covering card and bank charges, authorizations, captures, voids and refunds, 7 reporting nodes for transactions, settled batches and merchant details, 16 customer profile nodes for stored payment profiles and shipping addresses, 7 recurring billing nodes, and the vendor's own authentication probe. That splits 16 read nodes and 27 action nodes, and 18 are flagged destructive because they move money, schedule money, or reach a real customer.
Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. On a payment gateway the useful agent surface is mostly the read half: an assistant can reconcile a settlement with Authorize.Net: List Settled Batches, explain a specific charge with Authorize.Net: Get Transaction Details, and check whether a subscription is still active with Authorize.Net: Get Subscription Status. The 18 destructive nodes are flagged precisely so they can sit behind a condition or an approval step instead of behind a sentence in a prompt.
Authorize.Net has not published an MCP server. Its GitHub organization holds a repository named for one, but the repository is empty, with no code, no readme and no releases, and neither the API reference nor the developer site mentions a server anywhere. So the honest answer today is that none was found, with the caveat that the vendor has clearly staked the name and this could change without notice. In the meantime this connector is how the gateway reaches an assistant, and more to the point it is how the gateway reaches an unattended workflow: typed nodes that run on a schedule or another app's event, chain with every other connector, and hold the Transaction Key once in a shared workspace rather than in one person's local config.
Three facts about this API are unusual enough that the whole page is built around them, and every one of them is a way to lose money quietly. A failed transaction is not an HTTP error: the gateway answers 200 for a decline and for a bad credential alike, so a workflow has to branch on the result code inside the body rather than on the node's success flag. Amounts are decimal major units, so 5.00 is five dollars and so is 5, which is the opposite convention from several other payment connectors and a hundredfold error in the direction that overcharges someone. And there is no idempotency key on this API at all: the substitute is a duplicate window measured in seconds, and subscriptions have no duplicate protection whatsoever, so a retried subscription create makes a second subscription billing the same customer.
One connection, three surfaces
- Visual automations. Drag Authorize.Net nodes onto the canvas and wire them to triggers, conditions, and other apps.
- AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
- The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.
Every Authorize.Net node, ready to drop on the canvas
43 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.
Read and query nodes 16
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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.
Connecting Authorize.Net takes one credential
Authorize.Net does not use an authorization header, a bearer token or basic auth. Credentials travel inside the request body as a merchant authentication block, which the connector builds for you, in the exact position the gateway's schema requires. The two values are the API Login ID and the Transaction Key, both from the Merchant Interface under Account and then API Credentials and Keys, where the Transaction Key is shown once at generation. The third value on the credential is the environment, and it matters more than it looks: sandbox and production are genuinely different hosts with genuinely different accounts, and nothing in an API Login ID says which one it belongs to. So the environment lives with the credential rather than on the nodes, a node-level switch would let one workflow point half its steps at the wrong ledger, and the default is sandbox. An unrecognised value is rejected outright rather than falling back, because a silent fallback in that direction is the same accident with extra steps. Getting a sandbox account is genuinely free and genuinely quick: the vendor's sandbox signup asks for no card, no merchant application and no production account, which means the entire node catalog, including the money-moving half, can be exercised properly before anything real is connected.
Decide which account you are connecting. For a first build, use a sandbox account from the vendor's developer sandbox signup, which needs no card and no merchant application.
In the Merchant Interface, open Account and then API Credentials and Keys. Copy the API Login ID, and generate a Transaction Key if you do not already have one, copying it immediately because it is shown once.
In Mattering Automations, open Connectors, click Add Connector, choose Authorize.Net, and create a credential with those two values. Leave the environment on sandbox until the workflow is proven.
Click Test Connection. Mattering calls the vendor's own authentication probe, which reads nothing and writes nothing. Note what a failure looks like here, because it is the whole story of this API in miniature: an invalid credential comes back as HTTP 200 with an error result code and the code for failed authentication, not as a 401.
All 43 Authorize.Net nodes appear in the canvas palette. Build and test everything against sandbox first, then create a second credential for production and switch the nodes over deliberately.
Common uses for the Authorize.Net MCP
Reconcile settlement without exporting a report
Authorize.Net: List Settled Batches windows on settlement date and returns the batches that closed, Authorize.Net: Get Batch Statistics adds the additive numbers for one batch (charges, refunds, declines, errors, chargebacks), and Authorize.Net: List Transactions opens a batch up row by row. A scheduled run can write all of it into a Mattering database next to yesterday's, and open a task for a person only when a number moves further than a normal day should. This is entirely read-only, which makes it the natural first workflow to build on this connector.
Store a card without the card number touching the automation
Authorize.Net: Create Customer Profile From Transaction turns a payment that already happened into a stored customer profile using the payment data the gateway already holds, which is the cleanest way to end up with a reusable instrument: the full card number never passes through the workflow at all. From there Authorize.Net: Get Customer Profile reads the stored payment profiles and shipping addresses, Authorize.Net: Create Customer Shipping Address and Authorize.Net: Update Customer Payment Profile maintain them, and Authorize.Net: List Customer Profile IDs enumerates what exists. Responses are masked by the gateway, so a stored card comes back as its last four digits.
Charge a stored profile, deliberately and once
Authorize.Net: Charge Customer Profile bills a stored instrument, which means no second approval from the customer stands between the workflow and the money. Two guardrails belong on any workflow that uses it. Put a condition or an approval task in front of it rather than a bare trigger, since the node is flagged destructive for exactly this reason. And set a duplicate window on the transaction settings, because this API has no idempotency key: the duplicate window is the only thing that stops a retried run charging twice. If what you actually want is a hold you can release rather than a charge, Authorize.Net: Authorize Customer Profile takes the authorization and Authorize.Net: Void Transaction releases it.
Triage the held-for-review queue
Transactions held by fraud filters sit in their own queue, and Authorize.Net: List Unsettled Transactions reads it when its status filter is set to the pending approval value. From there a workflow can enrich each one with Authorize.Net: Get Transaction Details, route it to a person as a Mattering task with the customer and amount attached, and act on the decision with Authorize.Net: Approve or Decline Held Transaction. Be clear about what that node does before you automate it: approving releases real money, and declining kills the transaction permanently, with no route back other than charging again from scratch.
Run recurring billing from the same place as the rest of the business
Authorize.Net: Create Subscription and Authorize.Net: Create Subscription From Customer Profile start an Automated Recurring Billing schedule, Authorize.Net: List Subscriptions and Authorize.Net: Get Subscription Status report on them, Authorize.Net: Update Subscription changes the amount, the card or the schedule, and Authorize.Net: Cancel Subscription stops future charges. Two things to design around, both stated on the nodes. A subscription bills on its start date, which can be today, with no approval step anywhere between the call and the money. And cancelling is one way: the vendor documents no reactivation, so resuming means a new subscription on a fresh schedule, and it refunds nothing that was already collected.
Reverse a payment the right way for its stage
Voiding and refunding are not two names for the same thing, and picking the wrong one 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, but it is terminal, since a voided transaction can never settle and collecting that money later means a new charge. Authorize.Net: Refund Transaction applies after settlement and 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, and the original charge stays on the customer's statement beside it. A workflow that reverses payments should check whether the transaction has settled and branch, rather than reaching for one node for both cases.
Example: A nightly settlement reconciliation that only wakes someone when the numbers move
Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.
Trigger: a nightly schedule fires in Mattering Automations.
Authorize.Net: List Settled Batches returns the batches that settled in the window. Note that this node does not page, it windows on settlement date, so keep the window short.
For each batch, Authorize.Net: Get Batch Statistics returns the charge and refund counts and amounts, plus declines, errors and chargebacks. Every node here answers HTTP 200 whatever happens, so the first branch in the run reads the result code inside the body rather than the node's success flag.
The totals land in a Mattering database next to the previous night's, which is what makes drift visible rather than merely available.
A condition compares chargebacks and declines against a threshold you set. Below it, the run ends silently.
Above it, Authorize.Net: List Transactions opens the batch row by row, and a Mattering task opens for a person with the offending transactions attached. Nothing in this workflow moves money, which is the point: the money-moving nodes stay behind a human decision.
Authorize.Net MCP questions, answered
What Authorize.Net operations are supported?
43 nodes: 16 read and 27 action. Payments (charge a credit card, authorize a card, capture a prior authorization, capture only, void, refund, debit and credit a bank account, charge and authorize a stored customer profile, approve or decline a held transaction, send a customer a transaction receipt). Reporting (transaction details, transactions in a batch, unsettled transactions, transactions for a customer, settled batches, batch statistics, merchant details). Customer profiles (create, get, list ids, update and delete a profile, create, get, list, validate, update and delete payment profiles, create, get, update and delete shipping addresses, and create a profile from an existing transaction). Recurring billing (create a subscription, create one from a customer profile, get, get status, list, update and cancel). Plus the vendor's authentication probe. Deliberately not built: card-present and retail flows carrying full track data, the hosted payment page and Accept Suite token endpoints, Account Updater, split tender, PayPal Express through the gateway, and webhooks, which run on a separate REST service with its own authentication.
Does this work with Claude, ChatGPT, or other AI assistants?
Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and use them. Matter, the assistant built into the platform, uses the same nodes natively. On this connector specifically, think carefully about which nodes an assistant should reach. The 16 read nodes make a genuinely useful assistant surface for reconciliation and support questions. The 18 destructive nodes move money, and they are flagged so you can keep them behind a condition or an approval step rather than behind a well-worded instruction.
Does Authorize.Net publish its own MCP server?
Not today. The vendor's GitHub organization contains a repository whose name reserves the idea, but it is empty: no code, no readme, no releases. Nothing in the API reference or on the developer site mentions an MCP server. So this is a none found rather than a never, and the fact that the name has been staked suggests it may change, which is worth a re-check if it matters to your decision. What this connector offers in the meantime is not only MCP access but unattended execution: 43 typed nodes that run on a schedule or another app's event with nobody present, chain with every other connector so a settled batch can update a database and open a task in one run, hold the Transaction Key in a shared workspace store, and mark every money-moving operation as destructive.
If a payment is declined, does the node fail?
No, and this is the single most important thing to know before building anything here. Authorize.Net answers HTTP 200 for a decline, for a malformed request, and for an invalid credential alike, so the node envelope reports success even when no money moved. Two levels have to be read. The outer one is the result code in the messages block, which is Ok or Error and tells you whether the request itself succeeded, alongside a message code where an I prefix is informational and an E prefix is an error. The inner one is the transaction response code, where 1 is approved, 2 is declined, 3 is an error and 4 is held for review, with the actual reason for a decline in the transaction response errors rather than in the outer messages. They disagree on purpose: a decline arrives as an outer error with an inner code of 2 or 3, while a held-for-review transaction can arrive as an outer Ok with an inner code of 4. Read only the outer one and you misclassify holds, read only the inner one and you miss malformed requests, which have no transaction response at all. Every transaction node's description carries the full rule, and the connector deliberately does not reinterpret any of it into the success flag, because deciding what held for review means is the workflow author's call.
How are amounts expressed?
In decimal major units. An amount of 5.00 is five dollars, and so is 5. This is the opposite of the convention on some other payment connectors, where the same field is an integer count of the smallest unit, so confusing the two is a hundredfold error in the direction that overcharges a real person. Every money field in the node configuration states the unit in the same words for 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. The currencies the vendor lists are USD, CAD, GBP, DKK, NOK, PLN, SEK, EUR, AUD and NZD.
What happens if a workflow retries and charges twice?
There is no idempotency key on this API, so this is a real risk rather than a theoretical one, and the protection has to be configured. The vendor's substitute is a duplicate window on the transaction settings, a number of seconds during which an identical transaction is rejected as a duplicate rather than charged again, up to a documented maximum of 28800 seconds. Every transaction node that can be retried destructively exposes those settings and says to use them. Subscriptions have no equivalent protection at all: a retried create makes a second subscription billing the same customer, so dedupe above the connector for anything that creates one from a public form or another retrying source. On rate limits there is nothing numeric to report, because the vendor publishes no requests per second figure, no 429 documentation and no quota table. The published caps are structural instead: 1000 rows per page, 30 line items per transaction, 20 user fields per transaction, and an offset that is a page number starting at 1 rather than a row count.
Can I try this without a merchant account?
Yes, and this is one of the nicer things about this gateway. The vendor's developer sandbox signup issues a sandbox account with its own API Login ID and Transaction Key, and asks for no card, no merchant application and no production account. Sandbox and production are separate hosts with separate credentials, and the connector defaults to sandbox for that reason. The vendor also publishes test card numbers and specific values that force particular outcomes, so the decline path and the held-for-review path can be tested deliberately rather than waited for. That means the entire catalog, including the destructive half, can be exercised properly before anything real is connected, which is exactly how the first version of a payment workflow should be built.
Does card data pass through Mattering?
Only if you choose a path that puts it there, and the connector is built to make the other path easier. The charge, authorize and payment-profile nodes can accept a card number, because the gateway's API does, but the recommended route is to avoid that entirely: Authorize.Net: Create Customer Profile From Transaction builds a stored profile from a payment that already happened using the data the gateway already holds, after which the stored profile nodes bill it without a card number ever entering the workflow. On the way back, the gateway masks payment instruments itself, so a stored card returns as its last four digits and a masked expiry, and the connector scrubs anything card-shaped from output as well, since node output lands in run logs, databases and assistant context. The card-present family, which carries full track and chip data, is not built at all. Card data handling stays your PCI obligation, and the stored-profile path is the one that keeps the automation out of scope for the worst of it.
Put Authorize.Net to work inside your workspace
Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.
All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Authorize.Net is a product of its respective owner; Mattering is an independent platform.