Ellipse Gradient for Header

Authorize.net Integration Guide

Connect Authorize.net payment transactions, customer profiles, recurring billing, reporting, and selected webhook events with enterprise workflows and applications.

Authorize.net integration options at a glance

Authorize.net provides JSON and XML REST-style APIs for payment transactions, captures, refunds, voids, Customer Profiles, Payment Profiles, subscriptions, transaction history, and settlement reporting. It also supports webhook notifications for selected documented event types, allowing asynchronous payment status processing through a callback endpoint. API calls use an API Login ID and Transaction Key, while webhook signatures are validated with a Signature Key. Martini can consume these APIs, receive webhook callbacks through an exposed REST API, map payment data, orchestrate workflows, and maintain checkpoints for reporting synchronization. Reporting and settlement retrieval should use documented date windows or pagination rather than assuming unrestricted bulk export.

Integration pointSupported by Authorize.net?Common use casesHow Martini supports it
REST APIsYesCreate and manage transactions, captures, refunds, voids, Customer Profiles, Payment Profiles, subscriptions, transaction details, and reporting data using JSON or XML HTTP requests.Martini can consume the documented REST-style APIs, map request and response structures, apply business rules, and expose controlled internal APIs for upstream applications.
Webhooks / outbound callbacksLimitedReceive notifications for selected documented payment and account events; webhook coverage is not universal for every transaction state or API operation.Martini can expose a REST API endpoint, validate the Signature Key-based notification signature, acknowledge promptly, and process events idempotently.
Bulk / async / batch APIsLimitedRetrieve transaction history and settlement information for reporting and reconciliation. No unrestricted general-purpose bulk export mechanism was confirmed.Martini can run scheduled workflows using documented pagination or date windows, persist checkpoints, overlap polling windows, and deduplicate by Authorize.net identifiers.
AuthenticationYesAuthenticate API calls with an API Login ID and Transaction Key, and validate webhook notifications with a Signature Key. Sandbox and production credentials differ.Martini can store credentials in protected secrets or environment configuration and keep sandbox and production settings separate from workflow logic.
JSON APIsYesUse JSON request and response payloads for the documented transaction, profile, recurring billing, and reporting operations.Martini can transform canonical business data into JSON payloads and normalize Authorize.net responses for downstream systems.
XML APIsYesUse XML request and response payloads where required by a selected Authorize.net operation or existing integration dependency.Martini can map and transform XML messages while keeping vendor-specific payload handling isolated from broader workflow logic.
SOAP APIsLegacyThe current reference is centered on REST-style HTTP operations; historical SOAP dependencies should be confirmed before migration.Martini can consume SOAP services generally, but new Authorize.net integrations should prefer the documented REST-style APIs unless a legacy dependency is verified.
SDKsYesAuthorize.net publishes SDKs for several programming languages, although the underlying HTTP APIs are the more direct fit for explicit workflow orchestration.Martini can consume the underlying HTTP APIs directly, centralizing mapping, secrets, logging, and error handling rather than depending on a vendor SDK.

How Authorize.net exposes data and business events

Authorize.net REST APIs

Authorize.net documents JSON and XML REST-style HTTP APIs for transactions, captures, refunds, voids, Customer Profiles, Payment Profiles, subscriptions, transaction details, transaction history, and settlement reporting.

Martini implementation pattern

Martini implementation pattern: a workflow receives an internal request or scheduled trigger, calls the appropriate Authorize.net API with protected credentials, transforms the response into a canonical model, and routes the result to the originating or downstream application.

Implementation sequence

Receive an API request or scheduled workflow input
Validate the payment, customer, or reporting request
Map the canonical model to the Authorize.net JSON or XML structure
Call the documented Authorize.net API
Classify the response as success, decline, validation error, or technical failure
Write the normalized result and retain relevant identifiers

Authorize.net Webhooks

Authorize.net supports webhook notifications for selected documented event types. These notifications are asynchronous and should not be treated as a universal stream for every transaction state or API operation.

Martini implementation pattern

Martini implementation pattern: expose a REST API endpoint for the callback, validate the Signature Key-based signature, acknowledge promptly, persist the event for idempotent processing, and query Authorize.net when the notification lacks authoritative transaction detail.

Implementation sequence

Receive the Authorize.net webhook notification
Validate the webhook signature and payload
Persist the event identifier and processing status
Return a prompt acknowledgment
Retrieve authoritative transaction details when required
Apply downstream updates through an idempotent workflow

Authorize.net Reporting and Settlements

Authorize.net provides transaction history and settlement reporting operations for reconciliation, but the research does not confirm a general-purpose unrestricted bulk export API.

Martini implementation pattern

Martini implementation pattern: run a scheduled workflow over documented date windows or pagination, maintain a checkpoint with a small overlap period, deduplicate by Authorize.net identifiers, and map results into finance or ERP structures.

Implementation sequence

Start the scheduled reconciliation workflow
Load the last successful checkpoint and overlap window
Retrieve transaction or settlement data for the bounded period
Map amounts, statuses, batches, and identifiers to the finance model
Detect duplicate postings and reconciliation discrepancies
Persist the new checkpoint and report failures

Common Authorize.net integration patterns

Pattern 1: Orchestrate order payments

When to use this pattern

Use this pattern when an order or commerce application needs a controlled payment API rather than direct coupling to Authorize.net. Martini validates the request, submits the transaction, normalizes approval or decline results, and prevents uncertain retries from creating duplicate charges.

Integration direction
Order application
Martini
Authorize.net
Example Mapping
Authorize.net FieldCanonical FieldTarget Field
transactionRequest.amountorder.totalAmounttransactionRequest.amount
transactionRequest.paymentpayment.instrumentReferencetransactionRequest.payment
order.idpaymentRequestIdmerchantDefinedData or correlation reference
transactionResponse.transIdpayment.transactionIdorder.paymentTransactionReference
Martini implementation pattern

Expose a Martini REST API, validate amount, currency, merchant configuration, and an internal payment request identifier, then map the request to the Authorize.net transaction API. Store the result and return a normalized response. Treat declines as business outcomes and use duplicate detection before retrying timeouts or uncertain responses.

Martini capabilities used
  • APIs
  • workflows
  • API consumption
  • data mapping
  • business rules
  • error handling

Pattern 2: Process asynchronous payment events

When to use this pattern

Use this pattern when payment status can change after the original transaction request or when selected Authorize.net webhook events need to update order, finance, or service systems.

Integration direction
Authorize.net
Martini
Order or finance application
Example Mapping
Authorize.net FieldCanonical FieldTarget Field
eventNotification.eventIdpaymentEventIdexternalEventReference
eventNotification.eventTypepaymentStatusEventorder.paymentStatus
payload.data.transIdpayment.transactionIdorder.paymentTransactionReference
notificationDateeventReceivedAtpaymentStatusUpdatedAt
Martini implementation pattern

Receive the callback through a Martini API, validate the webhook signature, acknowledge quickly, and persist the event before downstream processing. Check event and transaction identifiers for duplicates, retrieve current transaction details when necessary, and route failures to controlled retry or exception handling.

Martini capabilities used
  • APIs
  • webhook consumption
  • workflows
  • idempotency rules
  • data mapping
  • error handling

Pattern 3: Synchronize customer and payment profiles

When to use this pattern

Use this pattern when a customer or commerce platform needs Authorize.net-managed Customer Profiles and Payment Profiles for future payment operations while minimizing sensitive payment-data storage in other systems.

Integration direction
Customer platform
Martini
Authorize.net
Example Mapping
Authorize.net FieldCanonical FieldTarget Field
profile.merchantCustomerIdcustomer.externalIdprofile.merchantCustomerId
profile.descriptioncustomer.displayNameprofile.description
paymentProfile.customerTypepaymentInstrument.typepaymentProfile.customerType
customerProfileIdauthorizeCustomerProfileIdcustomer.paymentProfileReference
Martini implementation pattern

Map canonical customer data to profile requests, apply validation and merchant-account rules, call the Customer Profiles and Payment Profiles APIs, and store only the identifiers required for future operations. Avoid logging raw card data or security codes and route profile errors without exposing sensitive payloads.

Martini capabilities used
  • API consumption
  • workflows
  • data mapping
  • validation
  • secrets management
  • security controls

Pattern 4: Reconcile transactions and settlements

When to use this pattern

Use this pattern for scheduled finance processing that compares Authorize.net transaction and settlement activity with orders, invoices, or receivables in an ERP or finance application.

Integration direction
Authorize.net
Martini
ERP or finance application
Example Mapping
Authorize.net FieldCanonical FieldTarget Field
transaction.transIdpayment.transactionIdexternalPaymentId
transaction.amountpayment.amountpayment.amount
settlement.batchIdsettlement.batchIdreconciliationBatchReference
transaction.statuspayment.statuspayment.postingStatus
Martini implementation pattern

Start a scheduled Martini workflow using a bounded date range or documented pagination, include a small overlap window, deduplicate by transaction and settlement identifiers, and map results to the target finance model. Apply reconciliation rules, retain checkpoints, and isolate failed postings for retry without duplicating successful entries.

Martini capabilities used
  • scheduled workflows
  • API consumption
  • data mapping
  • business rules
  • checkpointing
  • error handling

Applications commonly integrated with Authorize.net

Authorize.net payment and settlement data can be coordinated with commerce, finance, customer, and service applications. Martini provides a controlled orchestration layer for payment requests, webhook processing, reconciliation, and downstream updates without requiring a dedicated Authorize.net connector.

Application Scenario Direction Martini Pattern
Salesforce Synchronize payment status, customer identifiers, refunds, and transaction references with Accounts, Contacts, or custom payment objects. Salesforce → Martini → Authorize.net Expose a Martini API for payment actions, map Salesforce payment data to Authorize.net transaction requests, and process Authorize.net responses and selected webhook events into normalized Salesforce updates.
NetSuite Post successful payments, refunds, settlement data, and reconciliation references against customers, sales orders, or invoices. Authorize.net → Martini → NetSuite Use transaction and settlement retrieval workflows with date windows and checkpoints, map Authorize.net identifiers to NetSuite payment and reconciliation fields, and apply duplicate-posting controls.
Shopify Coordinate commerce order payment requests and payment-status synchronization where Authorize.net is part of the payment architecture. Shopify → Martini → Authorize.net Receive an order payment request, validate amount and idempotency data, submit the Authorize.net transaction, and route the result or later webhook status back to the order process.
WooCommerce Process or reconcile order payments and update payment states for commerce transactions. WooCommerce → Martini → Authorize.net Orchestrate payment requests through a Martini API, transform order totals and customer references, and use webhook or reporting workflows to reconcile final transaction status.
Microsoft Dynamics 365 Synchronize customer payments, invoices, refunds, and settlement information with finance and customer-service processes. Microsoft Dynamics 365 → Martini → Authorize.net Map Dynamics payment or invoice requests to Authorize.net operations and transform transaction and settlement responses into finance-specific updates with retry and duplicate controls.
SAP S/4HANA Feed payment and settlement results into receivables and reconciliation processes. SAP S/4HANA → Martini → Authorize.net Run scheduled reporting workflows, maintain a settlement checkpoint, map transaction identifiers and amounts to SAP structures, and route discrepancies for review.
ServiceNow Create or update payment-related cases, service requests, or financial exception records when transactions fail or require review. Authorize.net → Martini → ServiceNow Classify declines, configuration errors, and reconciliation exceptions in Martini, then create or update ServiceNow records with safe transaction references and diagnostic context.
Zendesk Surface payment failures, refunds, or transaction references to customer-support agents. Authorize.net → Martini → Zendesk Consume selected webhook events or reconciliation results, remove sensitive payment data, and update Zendesk with customer-safe status and transaction identifiers.

How to build a Authorize.net integration in Martini

Objective

Establish separate sandbox and production configurations and protect the credentials required for Authorize.net API calls and webhook validation.

Instructions in Martini

  • Store the API Login ID, Transaction Key, and Signature Key in protected Martini secrets or environment configuration.
  • Keep sandbox and production endpoints and credentials separate.
  • Restrict logs and access so credentials and sensitive payment data are not exposed.

Objective

Select an API, webhook, or scheduled trigger according to the business process and the availability of Authorize.net events.

Instructions in Martini

  • Use an exposed Martini REST API for synchronous payment requests.
  • Use a webhook callback for selected Authorize.net event types.
  • Use a scheduler for transaction and settlement reconciliation.

Objective

Acquire payment, profile, webhook, transaction, or settlement data from the appropriate Authorize.net mechanism.

Instructions in Martini

  • Call the documented JSON or XML API for the required operation.
  • Validate webhook signatures before applying event data.
  • Use bounded date windows or pagination for reporting retrieval.

Objective

Coordinate validation, vendor API calls, event persistence, downstream updates, and exception paths in a maintainable Martini workflow.

Instructions in Martini

  • Separate transport failures, declines, validation errors, and merchant configuration errors.
  • Persist correlation, transaction, settlement, and event identifiers.
  • Acknowledge webhook requests promptly before longer downstream processing.

Objective

Translate Authorize.net payloads into canonical business models and target-specific structures without losing important audit identifiers.

Instructions in Martini

  • Map amounts using decimal-safe logic and validate currency and totals.
  • Normalize transaction statuses, profile identifiers, settlement batches, and event types.
  • Avoid propagating raw card data, security codes, or transaction keys.

Objective

Prevent duplicate charges and duplicate postings while distinguishing payment outcomes from technical failures.

Instructions in Martini

  • Check internal payment request identifiers before retrying uncertain calls.
  • Process webhook events idempotently and tolerate duplicate or out-of-order delivery.
  • Treat declines as business outcomes rather than transient transport failures.

Common Authorize.net data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
TransactionsRepresent authorizations, captures, refunds, voids, declines, and related transaction details.Commerce applications, Salesforce, NetSuite, Microsoft Dynamics 365, SAP S/4HANAMartini maps transaction requests and responses, distinguishes approval, decline, and technical errors, stores transaction identifiers, and applies idempotency controls.
Customer ProfilesRepresent reusable customer records associated with payment and shipping information.Commerce applications, Salesforce, Microsoft Dynamics 365, customer platformsMartini creates or updates profiles from canonical customer data and retains only the Authorize.net identifiers needed for future operations.
Payment ProfilesRepresent stored customer payment instruments such as cards or bank accounts.Commerce applications, customer platforms, payment workflowsMartini should minimize handling of sensitive data, use profile identifiers where possible, and avoid logging raw payment credentials.
SubscriptionsRepresent recurring billing arrangements managed through the Automated Recurring Billing API.Commerce applications, Salesforce, finance applicationsMartini maps subscription requests and status data, applies merchant-specific business rules, and routes lifecycle changes to downstream systems.
Webhook EventsNotify receiving systems about selected payment and account events.Order systems, finance applications, Salesforce, ServiceNowMartini validates signatures, persists event identifiers, acknowledges quickly, handles duplicates and ordering issues, and queries authoritative transaction details when needed.
SettlementsProvide settlement batch information and settlement status for reconciliation and reporting.NetSuite, SAP S/4HANA, Microsoft Dynamics 365, finance data storesMartini retrieves settlement data on a schedule, maps batches and identifiers to finance models, maintains checkpoints, and flags reconciliation gaps.

Authentication and security considerations

Credential-based authentication

Authorize.net API calls generally use an API Login ID and Transaction Key rather than a general OAuth 2.0 flow. Webhook notifications use a Signature Key for signature validation, and API communication is performed over HTTPS.

Secrets and environments

  • Store the API Login ID, Transaction Key, and Signature Key in protected Martini secrets or environment configuration.
  • Separate sandbox and production credentials and endpoints.
  • Restrict access to payment credentials and avoid exposing them in logs or error payloads.

Payment data protection

Minimize the payment data that workflows receive and retain. Avoid logging raw card numbers, security codes, transaction keys, or complete sensitive payloads. Prefer Authorize.net-managed profiles or tokenized flows where appropriate and review PCI DSS responsibilities with the merchant’s security team.

Operational considerations for Authorize.net integrations

Retries and idempotency

Use internal payment request identifiers and persist Authorize.net transaction references. A transport timeout does not prove that a payment failed, so check for a completed prior attempt before retrying. Process webhook events idempotently using event and transaction identifiers.

Reporting and pagination

Use documented pagination or bounded date windows for transaction and settlement retrieval. Maintain a checkpoint and a small overlap window for delayed availability, then deduplicate by Authorize.net identifiers.

Webhook operations

Validate signatures, tolerate duplicate or out-of-order notifications, acknowledge quickly, and perform longer downstream processing in a controlled workflow. Query Authorize.net when an event does not contain sufficient authoritative transaction detail.

Testing and monitoring

Test approvals, declines, refunds, voids, duplicate requests, webhook delivery, and settlement behavior in the sandbox. Monitor response codes, workflow failures, webhook latency, reconciliation gaps, rate behavior, and schema or API changes.

Amounts and business outcomes

Use decimal-safe monetary logic, validate currency and totals, and distinguish payment declines from transport or authentication failures. Use bounded concurrency and exponential backoff for transient failures rather than retrying declines as network errors.

Why use Martini instead of scripts or point-to-point integrations?

Centralized orchestration

Martini provides a maintainable workflow layer between Authorize.net and order, finance, customer, and service applications. Payment calls, webhook processing, reporting synchronization, business rules, and exception paths can be managed consistently rather than duplicated across point-to-point scripts.

Explicit mapping and control

Martini can transform JSON and XML payloads into canonical and target-specific models, expose controlled APIs for upstream systems, and isolate Authorize.net request and response mappings from broader business workflows.

Operational reliability

Workflows can apply validation, idempotency, checkpointing, retry decisions, and monitoring practices appropriate for payment processing. This helps distinguish declines and business-rule failures from transient integration errors.

Secure configuration

Authorize.net credentials and environment settings can be managed outside workflow source definitions. Sensitive payment data can be minimized, protected, and excluded from operational logs while reusable integration logic remains available across deployments.

Frequently asked questions

How can Authorize.net be integrated with enterprise systems?

Authorize.net can be integrated through its JSON and XML REST-style APIs for transactions, Customer Profiles, Payment Profiles, subscriptions, reporting, and settlements. Selected webhook events can provide asynchronous notifications, while scheduled API retrieval supports reconciliation and synchronization.

Can Martini integrate with Authorize.net?

Yes. Martini can consume the Authorize.net REST APIs, send JSON or XML requests, receive selected webhook events through an exposed REST API, map payment data, and orchestrate updates to commerce, finance, customer, and service applications.

Do I need a connector to integrate Authorize.net with Martini?

No. A dedicated Authorize.net connector is not required. Martini can use Authorize.net’s native REST APIs, selected webhook mechanisms, API Login ID, Transaction Key, and Signature Key through API-consuming and workflow capabilities.

Is there any extra Lonti cost to integrate Authorize.net with Martini?

Lonti does not charge an additional per-connector or per-vendor fee to integrate Authorize.net. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Authorize.net, payment processing, cloud infrastructure, or other third-party services depending on subscription, usage, and deployment model.

Which Authorize.net integration methods should new implementations use?

New implementations should generally use the documented REST-style APIs with JSON or XML payloads, protected credential configuration, and selected webhooks where the required event types are available. Historical SOAP dependencies should be confirmed before migration because the current reference is centered on REST-style operations.

Are Authorize.net webhooks available for all payment events?

No. Authorize.net supports webhook notifications for selected documented event types, not necessarily every transaction state or API operation. Martini can validate signatures, process notifications idempotently, and use transaction or reporting APIs when authoritative data is needed.

How should Authorize.net synchronization and payment retries work?

Use API workflows for payment and profile operations, scheduled workflows with bounded date windows or pagination for reporting, and checkpoints with overlap windows for reconciliation. Preserve internal request identifiers and Authorize.net transaction references so uncertain calls and webhook deliveries can be handled without duplicate charges or postings.

How does Martini handle Authorize.net data mapping, errors, and sensitive payment data?

Martini can map Authorize.net structures into canonical and target-specific models, apply validation and business rules, and route technical failures separately from declines or other business outcomes. Credentials and sensitive payment data should be protected, raw card data should not be logged, and retries should use bounded backoff and idempotency controls.

Related Martini documentation

APIs

Workflows

Data and security

Operations

Connect Authorize.net with your enterprise systems

Use Martini to orchestrate Authorize.net payments, profiles, webhook processing, and settlement reconciliation through secure, maintainable workflows and APIs.

EXPLORE MARTINI
BOOK A DEMO