.png)
TaxJar Integration Guide
Connect TaxJar’s REST APIs to commerce, finance, and operational systems for tax calculation, transaction recording, lookup, and reconciliation workflows.
TaxJar integration options at a glance
TaxJar’s primary integration mechanism is a JSON REST API secured with an API key supplied as a bearer token. Applications can call the /v2/taxes resource for synchronous calculations, post order and refund transactions, and retrieve rates, categories, nexus regions, summaries, and returns. Transaction-oriented processing is available, but a general-purpose bulk or asynchronous API was not confirmed. TaxJar webhooks, outbound callbacks, GraphQL, SOAP, file transfer, and direct database access were not confirmed or supported for application integration. Martini can consume these REST resources, map commerce and financial data, expose a reusable tax API, schedule reconciliation workflows, and apply validation, retries, and business rules.
| Integration point | Supported by TaxJar? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | TaxJar’s primary interface provides JSON resources for tax calculations, order and refund transactions, rates, categories, nexus regions, summaries, and returns. | Martini can consume TaxJar REST endpoints from workflows, map request and response payloads, expose reusable APIs, and route results to commerce, finance, or data systems. |
| Synchronous tax calculations | Yes | Applications submit cart or order details to /v2/taxes and receive calculated tax amounts for checkout or order processing. | Martini can validate and transform addresses, shipping, amounts, quantities, and product tax codes before calling TaxJar and returning the response. |
| Transaction recording | Yes | Completed orders are posted under /v2/transactions/orders and refunds under /v2/transactions/refunds for reporting and compliance workflows. | Martini can separate calculation from commitment, use stable source identifiers, apply duplicate protection, and track posting status. |
| Lookup APIs | Yes | TaxJar provides rate, category, nexus, and related lookup resources for location and product-taxability decisions. | Martini can consume lookup responses, transform them for upstream applications, and apply caching or scheduled refresh policies where appropriate. |
| Bulk / async / batch APIs | Limited | Transaction-oriented processing is available, but a general-purpose bulk or asynchronous API covering all resources was not confirmed. | Martini can orchestrate controlled batches or scheduled calls, but volume, endpoint behavior, and account limits must be validated before historical imports. |
| Pagination and scheduled synchronization | Limited | Transaction resources and other collections may support documented filters and pagination; behavior should be confirmed separately for each resource. | Martini can schedule workflows, persist dates, identifiers, or cursors, and handle late-arriving records and corrections. |
| Authentication | Yes | TaxJar API requests use an API key in the Authorization bearer header; OAuth is not the normal documented model. | Martini can store the API key in protected secrets or environment configuration and inject it into outbound REST requests without exposing it in logs. |
| Webhooks / outbound callbacks | Not confirmed | No general TaxJar webhook or outbound callback mechanism was confirmed in the reviewed documentation. | Martini should use upstream application calls or scheduled polling rather than assuming TaxJar pushes transaction changes. |
| Database / analytics access | No | TaxJar does not expose customer database access for integrations. | Martini can retrieve supported TaxJar resources through the API and write transformed data to an approved database or reporting destination. |
How TaxJar exposes data and business events
TaxJar REST APIs
TaxJar’s REST API is the principal integration interface. It exposes JSON resources for tax calculations, order and refund transactions, rates, categories, nexus regions, summaries, and returns.
Martini implementation pattern
Martini implementation pattern: a workflow or Martini API receives a request, validates required business data, calls the appropriate TaxJar endpoint with the bearer API key, transforms the response, and returns or persists the result.
Implementation sequence
Synchronous tax calculations
TaxJar supports synchronous calculations through the /v2/taxes resource. A calling application submits order context and receives calculated tax amounts in the response.
Martini implementation pattern
Martini implementation pattern: expose a reusable tax-calculation API or invoke the workflow from an upstream commerce system, map line items and addresses, call TaxJar, and return a normalized tax response while distinguishing validation failures from transient API errors.
Implementation sequence
Transaction recording
TaxJar provides order and refund transaction resources for recording completed transactions and refunds. These operations support reporting and compliance workflows but are distinct from tax calculation.
Martini implementation pattern
Martini implementation pattern: trigger an order or refund workflow from the source application, transform the source transaction, submit it to the relevant TaxJar resource, and persist processing state so timeouts can be retried without creating unintended duplicates.
Implementation sequence
Scheduled synchronization
TaxJar resources such as transactions, summaries, and returns can be retrieved for reconciliation where documented filters and pagination support the account’s use case. A general event stream was not confirmed.
Martini implementation pattern
Martini implementation pattern: schedule a workflow that retrieves eligible TaxJar data, follows confirmed pagination behavior, maps results to an ERP, finance platform, warehouse, or database, and stores a checkpoint for the next run.
Implementation sequence
Lookup resources
TaxJar provides rate, category, and nexus lookup resources that can enrich commerce and product data. These resources are accessed through REST rather than through confirmed webhooks or database connectivity.
Martini implementation pattern
Martini implementation pattern: a workflow or API receives a location or product lookup request, calls TaxJar, applies local validation or normalization, and returns the result or stores it for controlled reuse.
Implementation sequence
Common TaxJar integration patterns
Pattern 1: Calculate checkout tax
When to use this pattern
Use this pattern when a commerce application needs a real-time tax amount before an order is completed. It keeps the commerce system decoupled from TaxJar’s request model while allowing the organization to centralize validation and response handling.
Integration direction
Example Mapping
| TaxJar Field | Canonical Field | Target Field |
|---|---|---|
| transaction_id | order.identifier | transaction_id |
| to_country | destination.country | to_country |
| shipping | order.shippingAmount | shipping |
| line_items[].unit_price | items[].unitPrice | line_items[].unit_price |
Martini implementation pattern
Martini exposes a controlled tax API or receives a commerce request, validates address and line-item completeness, maps the payload to /v2/taxes, calls TaxJar, and returns a normalized response. Business rules can reject incomplete addresses or unsupported tax categories, while bounded retries apply only to transient failures and not validation errors.
Martini capabilities used
- APIs
- workflows
- API consumption
- data mapping
- validation
- business rules
- error handling
Pattern 2: Record orders and refunds
When to use this pattern
Use this pattern when completed orders and refunds must be submitted to TaxJar for reporting and compliance after the checkout decision has been made.
Integration direction
Example Mapping
| TaxJar Field | Canonical Field | Target Field |
|---|---|---|
| order_id | transaction.sourceId | transaction_id |
| order_date | transaction.transactionDate | transaction_date |
| amount | transaction.totalAmount | amount |
| refund_reference | refund.sourceReference | transaction_reference |
Martini implementation pattern
A Martini workflow receives completed order or refund data, validates stable source identifiers, maps the appropriate TaxJar transaction structure, and posts to the order or refund resource. Processing state and correlation identifiers are persisted so a timeout can be retried safely; duplicate prevention and reconciliation rules separate calculation status from transaction-posting status.
Martini capabilities used
- workflows
- API consumption
- data mapping
- business rules
- idempotency handling
- error handling
- retries
Pattern 3: Enrich tax rates and categories
When to use this pattern
Use this pattern when commerce or product systems need TaxJar rate, category, or nexus information without embedding TaxJar-specific API logic in every application.
Integration direction
Example Mapping
| TaxJar Field | Canonical Field | Target Field |
|---|---|---|
| postal_code | location.postalCode | zip |
| product_tax_code | product.taxCategory | product_tax_code |
| state | location.region | state |
| jurisdiction | nexus.region | region |
Martini implementation pattern
Martini exposes a reusable lookup API or workflow that validates parameters, calls the relevant TaxJar resource, normalizes the response, and optionally stores approved lookup results for reuse. Business rules can map local product classifications to TaxJar categories and flag unmapped products for review.
Martini capabilities used
- APIs
- workflows
- API consumption
- data mapping
- validation
- business rules
- reusable integration assets
Pattern 4: Reconcile TaxJar reporting data
When to use this pattern
Use this pattern when finance or compliance teams need scheduled comparison of TaxJar transactions, summaries, or returns with ERP, order, or reporting data.
Integration direction
Example Mapping
| TaxJar Field | Canonical Field | Target Field |
|---|---|---|
| transaction_id | taxTransaction.externalId | externalTaxTransactionId |
| transaction_date | taxTransaction.date | transactionDate |
| sales_tax | taxTransaction.taxAmount | taxAmount |
| status | taxTransaction.processingStatus | reconciliationStatus |
Martini implementation pattern
A scheduled Martini workflow loads a checkpoint, retrieves supported TaxJar collections using confirmed filters and pagination, maps results to the target finance model, and records reconciliation outcomes. It handles late-arriving refunds, date boundaries, corrected transactions, rate limits, and partial failures without advancing the checkpoint past unprocessed data.
Martini capabilities used
- scheduled workflows
- API consumption
- pagination handling
- data mapping
- business rules
- checkpointing
- error handling
- monitoring
Applications commonly integrated with TaxJar
TaxJar can be integrated with commerce, payment, ERP, and customer-platform applications when tax calculation, transaction reporting, or reconciliation needs to be centralized. The exact supported product flow and account requirements should be validated for each application.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Shopify | Calculate sales tax during checkout and synchronize completed orders for tax reporting. | Shopify → Martini → TaxJar | Martini exposes or receives an order-tax workflow, maps Shopify cart, address, shipping, and line-item data to TaxJar’s /v2/taxes request, returns the calculation, and separately records completed transactions with stable order identifiers. |
| WooCommerce | Calculate tax for WooCommerce orders and submit completed order transactions to TaxJar. | WooCommerce → Martini → TaxJar | A Martini API or workflow validates WooCommerce order data, transforms product and address fields, calls TaxJar synchronously for calculation, and posts the resulting order transaction after completion with retry and duplicate protection. |
| BigCommerce | Provide tax calculations and transmit order transactions for compliance reporting. | BigCommerce → Martini → TaxJar | Martini orchestrates the tax request and transaction-recording steps, applies TaxJar category mappings, handles API responses, and stores processing status for reconciliation. Account-specific BigCommerce and TaxJar requirements should be verified. |
| Adobe Commerce / Magento | Centralize tax calculation and transaction reporting across online stores. | Adobe Commerce / Magento → Martini → TaxJar | Martini receives checkout or order events from Adobe Commerce, validates origin and destination data, maps line items and tax categories to TaxJar, and routes failures for controlled retry or review. |
| Stripe | Calculate tax for payment or billing flows and associate tax results with transactions. | Stripe → Martini → TaxJar | Martini coordinates Stripe transaction context with TaxJar tax calculation and transaction calls, returning the result to the billing workflow while maintaining correlation identifiers and avoiding duplicate submissions. The exact Stripe product flow should be validated. |
| NetSuite | Reconcile TaxJar transactions and tax summaries with ERP orders, invoices, and financial reporting. | NetSuite → Martini → TaxJar | A scheduled Martini workflow retrieves TaxJar transactions, summaries, or returns, maps them to NetSuite financial objects, applies date and status rules, and records checkpoints and reconciliation exceptions. |
| Salesforce Commerce Cloud | Provide tax calculation and transaction reporting for digital commerce orders. | Salesforce Commerce Cloud → Martini → TaxJar | Martini receives commerce order data, transforms addresses, shipping, amounts, and product tax categories for TaxJar, and returns calculated tax or records completed transactions with bounded retries. |
| Salesforce | Synchronize taxable sales, refunds, or custom order data with TaxJar when Salesforce supports commerce or revenue operations. | Salesforce → Martini → TaxJar | Martini exposes a controlled API or scheduled workflow that maps Salesforce order and refund data to TaxJar transaction resources, validates required fields, and persists processing outcomes. This is an API-led integration rather than a claim of a TaxJar-native Salesforce integration. |
How to build a TaxJar integration in Martini
Objective
Configure TaxJar API access without embedding credentials in workflow definitions or exposing them in logs or responses.
Instructions in Martini
- Create environment-specific TaxJar API key configuration.
- Store the key in Martini secrets or protected environment configuration.
- Configure the REST request with the Authorization bearer header.
- Keep development, testing, and production credentials separate where available.
Objective
Select an invocation model that reflects the business process because a general TaxJar webhook or callback mechanism was not confirmed.
Instructions in Martini
- Use an inbound Martini API for checkout or upstream application requests.
- Use an application-initiated workflow for completed orders and refunds.
- Use a scheduler for reconciliation and lookup refresh workflows.
- Do not assume TaxJar can push transaction events to Martini.
Objective
Call the appropriate TaxJar REST resource for calculation, transaction recording, lookup, or reporting data.
Instructions in Martini
- Call /v2/taxes for synchronous tax calculations.
- Post completed orders or refunds to the corresponding transaction resource.
- Retrieve rates, categories, nexus, summaries, or returns as required.
- Confirm endpoint-specific filters, pagination, and account limits before large synchronizations.
Objective
Translate source application models into TaxJar’s required request and response structures while preventing incomplete tax decisions.
Instructions in Martini
- Map addresses, shipping, amounts, quantities, dates, identifiers, and product tax categories.
- Validate required fields before making the TaxJar request.
- Normalize TaxJar responses for commerce, finance, or reporting consumers.
- Preserve correlation identifiers and relevant source references.
Objective
Separate tax calculation, transaction commitment, reconciliation, and exception decisions according to the organization’s process.
Instructions in Martini
- Distinguish calculated tax from successfully recorded transactions.
- Apply rules for exempt customers, unmapped categories, invalid addresses, and refund relationships.
- Use stable order or transaction identifiers for duplicate protection.
- Route unresolved validation and reconciliation exceptions for review.
Objective
Persist results in the calling application, ERP, database, or reporting destination with auditable processing state.
Instructions in Martini
- Return calculated tax to the originating commerce or billing flow.
- Write order and refund status to the source or finance system.
- Store TaxJar results and checkpoints for scheduled reconciliation.
- Avoid storing full sensitive request and response bodies unless required and protected.
Common TaxJar data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Tax calculations | Calculate tax for an order using origin, destination, shipping, product amounts, and related transaction details. | Shopify, WooCommerce, BigCommerce, Adobe Commerce / Magento, Salesforce Commerce Cloud | Martini validates and maps cart or order data to /v2/taxes, calls TaxJar synchronously, and returns or routes the calculated result. |
| Order transactions | Record completed or committed orders for reporting and tax-compliance workflows. | TaxJar, NetSuite, Salesforce, finance databases, reporting platforms | Martini transforms source orders, submits them to /v2/transactions/orders, tracks identifiers and status, and applies retry and duplicate controls. |
| Refund transactions | Record refunds associated with previously reported or committed transactions. | TaxJar, NetSuite, commerce platforms, finance databases | Martini maps refund references and amounts, posts them to /v2/transactions/refunds, and correlates the result with the source return or refund. |
| Nexus regions | Represent states or jurisdictions where a business has tax collection obligations. | Commerce platforms, ERP systems, tax configuration stores, reporting databases | Martini retrieves nexus information through /v2/nexus/regions and transforms it into configuration or compliance data. |
| Tax rates | Look up tax-rate information for a location. | Commerce platforms, pricing services, tax configuration stores | Martini calls /v2/rates, validates location inputs, and returns or caches normalized rate data where the business process permits. |
| Tax categories | Classify products for taxability and calculation behavior. | Product catalogs, Shopify, WooCommerce, BigCommerce, ERP systems | Martini retrieves /v2/categories data and maps TaxJar categories to product catalog or commerce tax-code fields. |
Authentication and security considerations
Bearer-token authentication
TaxJar API requests use an API key in the Authorization bearer header. OAuth is not the normal documented authentication model for TaxJar API consumption.
Secret management
Store TaxJar credentials in Martini secrets or protected environment configuration. Use environment-specific credentials where available and never embed API keys in workflows, mappings, logs, or public API responses.
Data protection
- Minimize logging of customer addresses, order details, authorization headers, and complete request or response bodies.
- Restrict access to the workflows and secrets that can call TaxJar.
- Apply organizational retention, masking, and encryption policies to tax and transaction data.
Operational considerations for TaxJar integrations
Rate limits and retries
TaxJar limits may depend on the account or subscription plan. Use controlled concurrency and bounded backoff for transient failures and rate-limit responses.
Pagination and checkpoints
Confirm filters, pagination parameters, and response metadata separately for transactions, summaries, returns, and lookup resources. Persist the last successful date, identifier, or cursor and account for late-arriving records.
Idempotency and transaction status
Use stable source order and refund identifiers. Treat tax calculation and transaction recording as separate business steps, and retain processing state so a timeout does not automatically create a duplicate.
Schema and testing
Validate addresses, line items, tax categories, dates, and amounts before calling TaxJar. Test sandbox or non-production credentials where available, monitor API documentation for changes, and avoid depending on undocumented response fields.
Why use Martini instead of scripts or point-to-point integrations?
Centralized orchestration
Martini can place TaxJar API calls, source-system validation, downstream writes, reconciliation, and exception handling in maintainable workflows instead of duplicating logic across commerce and finance applications.
Reusable API assets
Martini can expose a controlled tax-calculation API so multiple applications use a consistent contract while TaxJar-specific request and response models remain behind the integration boundary.
Reliable processing
Workflows can apply mapping, business rules, retries, checkpoints, and monitoring for order, refund, lookup, and scheduled reporting processes.
Flexible targets
Martini can transform TaxJar data for commerce applications, ERPs, databases, finance platforms, and reporting destinations without requiring direct TaxJar database access or a dedicated connector.
Frequently asked questions
TaxJar is primarily integrated through its JSON REST API at api.taxjar.com. Applications can call /v2/taxes for synchronous calculations, post order and refund transactions, and retrieve rates, categories, nexus regions, summaries, and returns. Authentication uses an API key in a bearer Authorization header.
Yes. Martini can consume TaxJar’s REST API from workflows and APIs, map commerce or financial data, calculate tax, record orders and refunds, retrieve lookup and reporting resources, and write normalized results to downstream systems. A native Martini TaxJar connector was not documented in the supplied research.
No. A dedicated TaxJar connector is not required. Martini can integrate with TaxJar using its confirmed REST API and bearer-token authentication, with workflows handling mapping, validation, orchestration, retries, and downstream delivery.
Lonti does not charge an additional per-connector or per-vendor fee to integrate TaxJar with Martini. Integrations are subject to the provisioned capacity of the Martini environment. Separate costs may apply from TaxJar, cloud infrastructure, or other third-party systems based on subscription, usage, and deployment model.
The recommended method is TaxJar’s REST API. Use /v2/taxes for synchronous calculation, transaction resources for orders and refunds, and lookup or reporting resources for rates, categories, nexus, summaries, and returns. GraphQL, SOAP, general file APIs, and direct database access were not confirmed or supported.
A general TaxJar webhook or outbound callback facility was not confirmed in the reviewed documentation. Integrations should generally be initiated by an upstream application calling Martini or by scheduled Martini workflows that retrieve supported TaxJar resources.
Martini can map source addresses, line items, shipping, amounts, transaction dates, product tax categories, and identifiers into TaxJar request models. Scheduled synchronization should use documented filters and pagination, persist a checkpoint, and account for late orders, refunds, corrections, and time-zone boundaries.
Use validation before outbound calls, bounded retries with backoff for transient failures and rate limiting, and separate handling for authentication or business validation errors. Stable source order and refund identifiers, persisted processing state, and reconciliation checks help prevent duplicate submissions after timeouts.
Related Martini documentation
Workflows
Build a maintainable TaxJar integration with Martini
Use Martini to connect TaxJar’s REST API with commerce, finance, ERP, and reporting systems through secure APIs, orchestrated workflows, reusable mappings, and controlled operational processes.