Menu

Mattering Automations FastSpring integration

Connect FastSpring to Mattering Automations: orders and order tags, customer accounts, coupons and codes, the full subscription lifecycle, returns, v2 checkout sessions, products and localized pricing, event recovery and reporting as workflow steps, authenticated with one FastSpring API credential set.

The Mattering Automations FastSpring integration adds the FastSpring API to your automation canvas: search and retrieve orders and tag them, find and manage customer accounts, run the whole subscription lifecycle (update, pause, resume, cancel, uncancel, managed charge, and the transaction entries behind each one), issue returns, create v2 checkout sessions, manage products, offers and localized pricing with a tax preview, build and delete coupons and their codes, recover missed events, and generate subscription and revenue reports.

The credential is a FastSpring API credential set: a username and a password created in the FastSpring app under Developer Tools, then APIs, then API Credentials, and sent as HTTP Basic on every request to api.fastspring.com. It is a pair, not a single bearer token, so both halves go into one Mattering credential. FastSpring also documents a mandatory User-Agent header on every API request; the connector sends one for you, which matters because a missing User-Agent fails at the request layer and looks like a broken endpoint rather than a missing header. Setup takes a few minutes, and this guide walks through each step and ends with the full node reference.

The safety modeling is stated on the nodes rather than buried. Of the 45 nodes, 25 read and 20 act, and eight carry a destructive flag: FastSpring: Create Return, FastSpring: Charge Managed Subscription, FastSpring: Update Subscription, FastSpring: Resume Subscription, FastSpring: Cancel Subscription, FastSpring: Delete Product, FastSpring: Delete Coupon, and FastSpring: Delete All Coupon Codes. Two of them hide it in the name. Resuming a subscription cancels a scheduled pause and charges the customer immediately, and updating a subscription with prorate set to true invoices the prorated difference against a live subscription. Both node descriptions say so, and both name the safe alternative: FastSpring: Pause Subscription is the reversible way to stop billing, and running an update with preview set to true returns the prorated charges and credits without committing anything.

Before you start

  • A FastSpring seller account, and access to Developer Tools inside it. That is where API credential sets are created, so whoever connects FastSpring to Mattering needs to be able to reach that section of the FastSpring app.
  • An API credential set: a username and a password. Both are required, because FastSpring authenticates with HTTP Basic over the pair rather than a single token.
  • A Mattering workspace with access to the Automations app.
  • An awareness of which mode your store is in. FastSpring signup is self-serve and a new store can be exercised straight away, but it starts in Test mode and cannot process real transactions until FastSpring activates it: a FastSpring representative walks the seller through KYC verification, and the store is switched to Live separately from anything you do here. One credential set still reaches both live and test data in the same store, so most read nodes take a scope of live or test and checkout sessions take a live flag. Build and run against test data until the store is live.
  • For the money-moving nodes, a decision about gating before you build. Eight nodes are flagged destructive and four of them move real money, so plan where an approval task or a condition sits in the workflow rather than adding it after the first surprise.

Create a FastSpring API credential set

Mattering authenticates to FastSpring with an API credential set: a username and a password, applied as HTTP Basic against api.fastspring.com. There is one global host and no environment to choose, which is why a single credential covers everything this integration does, and why the connection test is a plain authenticated GET. The pair is created inside the FastSpring app, not in an account settings page, so the path below is worth following exactly.

Sign in to the FastSpring app and open Developer Tools, then APIs, then API Credentials.
Create a credential set. FastSpring generates a username and a password for it. The username is not your login email; it belongs to the credential set.
The password half of the credential set is shown when the set is created. Copy it before you leave the page. If it is lost, the fix is to regenerate the credential in the FastSpring app, which invalidates the old password everywhere it is in use, including this integration.
One credential set reaches both live and test data. FastSpring does not run a separate sandbox host or a second account for testing, so there is no second credential to create; the scope field on the nodes is what selects live or test rows. FastSpring's own docs call a store's pre-activation state Test mode and describe it as a sandbox environment, so the wording differs, but it is the same host, the same store and the same credential.

Connect FastSpring to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose FastSpring from the list.
Click Create new credential, paste the API Username and the API Password from the credential set, and save.
The credential is stored encrypted in Google Secret Manager and never appears in workflow logs. The password half is registered for redaction on every execution.
Click Test Connection. Mattering calls FastSpring's product list endpoint, which is the cheapest authenticated call in the connector: it takes no parameters, a store with no products returns an empty products array, and a wrong credential returns 401 before any store data is touched.
Click Connect. All 45 FastSpring nodes appear in your canvas palette.

Verify it works

After connecting, open any automation canvas and check the palette: a FastSpring section should list the query and action nodes. Drop FastSpring: List Products onto the canvas and run a test step. It is the integration's natural probe, the same call the connection test makes, and it needs no configuration at all. Note the shape before you build on it: FastSpring returns product PATH STRINGS at data.products[], not product objects. Copy one path, because the product nodes, the price nodes and the offers node all ask for it.

Now run FastSpring: Get Product with that path and notice the asymmetry that catches people out: the single-product response wraps the product in a one element array, so its fields live at data.products[0], while single-entity reads elsewhere in this API return the object at the top level (data.total on an order, data.state on a subscription). Finish with FastSpring: List Subscriptions, which is the one lister that returns full objects rather than id strings: the node always sends a limit, and in practice that lister comes back on the enriched shape every run. Read the shape you get rather than the shape you expect, because FastSpring does not document a rule tying parameters to response shape. Everything in this verify path is read only: it cannot reach any of the eight destructive nodes and it changes nothing in the store, so it is safe to re-run whenever you rotate the credential.

Node reference

45 nodes, generated from the connector itself so this reference always matches what ships.

Read and query nodes 25

FastSpring: Download Report

fastspring_download_report

Download a completed report as CSV text. The body is not JSON, so it arrives as data.content with data.length and a data.truncated flag; very large reports are cut off at the connector's text cap, and truncated true means you should page the report instead.

FastSpring: Generate Revenue Report

fastspring_generate_revenue_report

Transaction level reporting over a date range: the numbers behind FastSpring's Revenue Overview dashboard. Pick the columns and grouping you want from the documented lists. With async_job false the rows come back inline at data.report[]; with async_job true you get a job id and an email when it finishes. The bucket width is whatever you group by, so a caller that wants a time series groups by transaction_date, transaction_day, transaction_month or transaction_year.

FastSpring: Generate Subscription Report

fastspring_generate_subscription_report

Subscription metrics over a date range: the numbers behind FastSpring's Subscription Overview dashboard. Pick the columns you want and how to group them. With async_job false the rows come back inline at data.report[]; with async_job true you get a job id instead, plus an email to the addresses you list, and you collect the result with FastSpring: Get Report Job and FastSpring: Download Report. To get one row per day, include occurred_date in BOTH report_columns and group_by.

FastSpring: Get Account

fastspring_get_account

Retrieve one customer account: contact details, address, language and country, lookup keys, stored payment method counts, and the ids of the account's orders and subscriptions. The account object is at the TOP level, so paths look like data.contact.email and data.subscriptions[].

FastSpring: Get Checkout Session

fastspring_get_session

Retrieve a checkout session's current state: status, expiry, customer, cart with calculated totals and tax, available payment methods, the checkout URL, and any warnings or outstanding checkoutStatus requirements. The session is at the TOP level of the response.

FastSpring: Get Coupon

fastspring_get_coupon

Retrieve one coupon: discount type and amount, how many billing periods it applies to, whether it combines with other discounts, its active date range, redemption limit, codes and the products it targets. The coupon is at the TOP level of the response. This endpoint returns at most 1,000 codes; use FastSpring: List Coupon Codes past that.

FastSpring: Get Order

fastspring_get_order

Retrieve one order: customer, billing address, payment method, totals, tax, discounts, line items and the invoice URL. The order object is at the TOP level of the response, so paths look like data.total and data.customer.email. Pass several order ids separated by commas and FastSpring returns an array instead.

FastSpring: Get Product

fastspring_get_product

Retrieve one product: localized display names and descriptions, image, SKU, visibility, and its configured offers. The response wraps the product in a one element array, so the fields live at data.products[0]. Separate several product paths with commas to fetch them in one call.

FastSpring: Get Product Offers

fastspring_get_product_offers

Retrieve the merchandising offers attached to a product: add-ons, alternatives, cross-sells, upsells, downsells, upgrades, downgrades and crossgrades. Filter to one kind with the type field.

FastSpring: Get Product Price

fastspring_get_product_price

Localized prices for one product, including applicable VAT or GST and any configured discount. Narrow the response with country, currency, or both.

FastSpring: Get Report Job

fastspring_get_report_job

Status of one report job: whether it has completed, when it was created and finished, and the download URL once it is ready. Poll this after queuing a report with async_job set to true.

FastSpring: Get Return

fastspring_get_return

Retrieve one return: refunded total, tax, reason, note, who performed it, the customer, the refunded line items, and a summary of the original order. Rows come back inside a returns array, so paths look like data.returns[0].totalReturn. Separate several return ids with commas to fetch them together.

FastSpring: Get Subscription

fastspring_get_subscription

Retrieve one subscription: state, product and display name, quantity, price and discount, add-ons, custom attributes, payment method summary, next charge date and any scheduled pause. The subscription is at the TOP level of the response, so paths look like data.state and data.nextChargeDate.

FastSpring: List Accounts

fastspring_list_accounts

Find customer accounts by email, lookup key, order, subscription, product, subscription state, or refund history. With no parameters FastSpring returns ACCOUNT ID STRINGS at data.accounts[]; the vendor documents that sending parameters returns fuller account records instead, so branch on the row type if you filter.

FastSpring: List Coupon Codes

fastspring_list_coupon_codes

Every code attached to a coupon, returned uppercase. Use this rather than FastSpring: Get Coupon when a coupon has more than 1,000 codes, which is where that endpoint stops.

FastSpring: List Coupons

fastspring_list_coupons

List every coupon path identifier on the store. FastSpring documents this as path identifiers ONLY, with expansion unsupported, so read data.coupons[] and call FastSpring: Get Coupon for a coupon's discount configuration and codes.

FastSpring: List Orders

fastspring_list_orders

Search orders by date range, product, status, mode and whether they are subscription rebills or carry returns. FastSpring returns ORDER ID STRINGS at data.orders[], not order objects, so pass the ids on to FastSpring: Get Order (which accepts several ids separated by commas).

FastSpring: List Processed Events

fastspring_list_processed_events

Events already marked processed, for auditing what your integration has handled. Same 30 day retention and same row shape as the unprocessed list.

FastSpring: List Product Prices

fastspring_list_product_prices

Localized prices for every product, keyed by country, including applicable VAT or GST, quantity discounts, discount reasons and setup fees. Without country or currency FastSpring returns each supported country in its default currency. FastSpring refreshes its exchange rates every 6 hours and recommends calling this at least daily if you cache prices.

FastSpring: List Products

fastspring_list_products

List every product path in the store. FastSpring returns PATH STRINGS only, not product objects, so read the rows at data.products[] and call FastSpring: Get Product for the details of any one of them. Takes no parameters, which makes it the cheapest authenticated call in the connector and the auth probe.

FastSpring: List Report Jobs

fastspring_list_report_jobs

Every report job and its status, with the download URL for completed ones. The response is a BARE ARRAY, so rows are at data[] and paths look like data[].status.

FastSpring: List Subscription Entries

fastspring_list_subscription_entries

Every transaction on a subscription: the original order, each renewal rebill, and the prorated adjustments from plan changes, each with its billing period dates and the full order object. The response is a BARE ARRAY, so rows are at data[] and the order under each is at data[].order.

FastSpring: List Subscriptions

fastspring_list_subscriptions

Search subscriptions by account, status, lifecycle event, product, mode and date range. FastSpring returns full subscription OBJECTS whenever any parameter is sent, and this node always sends limit, so rows arrive as objects at data.subscriptions[]. Always set event when you use begin and end, or the dates do not filter.

FastSpring: List Unprocessed Events

fastspring_list_unprocessed_events

Events FastSpring has not seen acknowledged yet, which is how you recover webhook deliveries your endpoint missed. Each row carries the event id, type, created timestamp and the full payload under data. FastSpring keeps events for 30 days and nothing older is returned. Mark them handled with FastSpring: Update Event.

FastSpring: Preview Product Tax

fastspring_preview_product_tax

Estimate indirect taxes (VAT, GST, sales tax) for one or more country and currency groups before a checkout exists. Creates nothing. Each returned item carries jurisdiction, taxCode, taxType, taxRate, taxPercent and taxPrice. For United States groups include zip at the GROUP level or the response can come back with a zero rate.

Action nodes 20

FastSpring: Add Coupon Codes

fastspring_add_coupon_codes

Append codes to an existing coupon. Additive: existing codes are preserved, unlike passing codes to FastSpring: Create or Update Coupon. Codes are stored uppercase and deduplicated case insensitively, and duplicates in one request are echoed back without error, so read the stored state back with FastSpring: List Coupon Codes.

FastSpring: Cancel Subscription

fastspring_cancel_subscription

DESTRUCTIVE: cancel a paying customer's subscription. billing_period 1 (FastSpring's default) ends it at the end of the current billing period; 0 ends it immediately. FastSpring: Uncancel Subscription can undo this, but ONLY before the deactivation actually lands, so this is not a clean round trip. If you want a reversible break in billing, use FastSpring: Pause Subscription instead.

FastSpring: Charge Managed Subscription

fastspring_charge_managed_subscription

DESTRUCTIVE: charge a managed subscription now. FastSpring processes the charge immediately and notifies the customer. Routine payment failures such as insufficient funds come back as HTTP 200 with a per subscription result of error, so check data.subscriptions[0].result, not just the status code; HTTP 400 is reserved for a hard decline or a subscription past its retry limit. Use simulate to rehearse without a real transaction. FastSpring recommends batching large renewal runs and waiting for each batch.

FastSpring: Create Account

fastspring_create_account

Create a customer account so a later checkout, session or subscription can be attached to it. No money moves. FastSpring recommends always sending country, because some payment methods require it and transactions can otherwise fail later.

FastSpring: Create Checkout Session

fastspring_create_session

Create a checkout session with the cart and customer already filled in, then send the shopper to data.checkoutUrls.webcheckoutUrl. Reversible write: a session is an intent, not a transaction. Nothing is charged until the shopper completes the page, and an abandoned session simply expires. The response carries everything you need, including calculated totals and a checkoutStatus listing anything still missing, so no follow-up read is required.

FastSpring: Create Return

fastspring_create_return

DESTRUCTIVE: refund an order, in full or in part. Real money goes back to the buyer, product access tied to the order is returned, and with notification set to ORIGINAL the buyer is emailed. There is no un-return. Leave refund_type blank or set FULL to refund the whole order; set PARTIAL and list items to refund named products only.

FastSpring: Create or Update Coupon

fastspring_upsert_coupon

Create a coupon, or update an existing one. FastSpring decides which from whether the coupon path identifier already exists, and reports it back as coupon.create or coupon.update. WARNING: sending the codes array on an update REPLACES every existing code; leave codes blank to keep them, and use FastSpring: Add Coupon Codes to append.

FastSpring: Create or Update Products

fastspring_upsert_products

Create products, or update existing ones, from a JSON array. FastSpring decides create or update from whether the product path already exists, and accepts up to 300 products in one call. Each entry needs product, display and pricing; subscription products add interval, intervalLength and trial settings.

FastSpring: Delete All Coupon Codes

fastspring_delete_coupon_codes

DESTRUCTIVE: permanently remove EVERY code for a coupon in one call. The coupon survives but cannot be applied at checkout until new codes are added, and the deleted codes cannot be restored. This is also the required first step before deleting the coupon itself.

FastSpring: Delete Coupon

fastspring_delete_coupon

DESTRUCTIVE: permanently delete a coupon. FastSpring refuses while the coupon still has active codes, so run FastSpring: Delete All Coupon Codes first. There is no undelete; to retire a coupon reversibly, set its available end date in the past instead.

FastSpring: Delete Product

fastspring_delete_product

DESTRUCTIVE: permanently delete a product from the catalog. FastSpring documents no undelete. If the product might come back, set its visibility to private with FastSpring: Create or Update Products instead.

FastSpring: Get Account Management URL

fastspring_get_account_portal_url

Mint an authenticated, expiring URL into this customer's Account Management Portal, where they can see orders and manage subscriptions and payment methods. Classed as a write rather than a read even though the verb is GET: anyone holding the returned URL is signed in as that customer until it expires, so treat it as a secret and send it only to the account owner. Append #/subscriptions to land on the Subscriptions tab.

FastSpring: Pause Subscription

fastspring_pause_subscription

Schedule a pause: on the next billing cycle date the subscription moves to paused instead of charging the customer, for the number of periods you name. Nothing is charged at execution, and the pause has a documented inverse in FastSpring: Resume Subscription, which is why this is the reversible way to stop billing.

FastSpring: Resume Subscription

fastspring_resume_subscription

DESTRUCTIVE despite the name: resuming a subscription that has a pause scheduled cancels that pause, and FastSpring then CHARGES THE CUSTOMER IMMEDIATELY and starts a new billing cycle. That is a real charge at API execution time, so treat this as a money-moving call, not a state toggle.

FastSpring: Uncancel Subscription

fastspring_uncancel_subscription

Undo a cancellation: clears the scheduled deactivation so the subscription keeps renewing, which FastSpring reports back through its subscription.uncanceled webhook. No money moves at execution and cancelling again is the inverse, so this is a reversible write. It only works while the subscription has NOT yet deactivated: once the cancellation lands there is nothing to uncancel.

FastSpring: Update Account

fastspring_update_account

Update a customer account. Only the fields you fill are changed; anything left blank keeps its current value. Email is required by FastSpring on this call even when you are only changing something else.

FastSpring: Update Event

fastspring_update_event

Mark an event processed or unprocessed. Bookkeeping only: it changes nothing about the order, subscription or customer the event describes, and setting the flag the other way is its own inverse.

FastSpring: Update Order Tags and Attributes

fastspring_update_order_tags

Attach or replace custom tags on an order, and custom attributes on the order's line items. Metadata only: nothing about the money, the fulfillment or the customer's access changes, and posting again with different values is the inverse.

FastSpring: Update Subscription

fastspring_update_subscription

DESTRUCTIVE: change a live subscription's product, quantity, price, discount, add-ons, coupons, next charge date, end date or renewal mode. With prorate set to true FastSpring calculates and invoices the prorated difference against the paying customer, so an upgrade can charge immediately. Set preview to true first: that returns the prorated charges and credits WITHOUT committing anything, which is the safe rehearsal for this node.

FastSpring: Update Webhook Key Secret

fastspring_update_webhook_key

Rotate the HMAC secret FastSpring uses to sign webhook payloads sent to one endpoint URL. Reversible by rotating again, but sequencing matters: make sure the receiving server can verify signatures with the new secret BEFORE you run this, because every delivery after it is signed with the new key. Discard the old secret afterwards.

Using the integration

On the automation canvas

FastSpring nodes chain with every other node. A support form can run FastSpring: Get Order and open an approval task in Mattering Productivity before anything is refunded, a nightly schedule can write FastSpring: Generate Subscription Report rows into a Mattering database, and FastSpring: List Unprocessed Events can drive a catch-up job for webhook deliveries your endpoint missed. Three values feed most downstream steps: the product path from FastSpring: List Products, the order id from FastSpring: List Orders, and the subscription id from FastSpring: List Subscriptions.

From AI assistants over MCP

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and Matter can drive the same surface. A billing question is mostly a question of fact, and the read nodes answer it: FastSpring: List Accounts finds the customer, FastSpring: Get Account returns their contact details and the ids of their orders and subscriptions, FastSpring: Get Subscription gives state, price, next charge date and any scheduled pause, and FastSpring: List Subscription Entries explains what each past charge was for. Hand an assistant the reads freely; keep the eight destructive nodes behind conditions or approval steps.

The listers return ids, so plan for two hops

Most FastSpring listers hand back plain strings rather than objects, and workflows that assume otherwise fail quietly on an empty template. FastSpring: List Orders returns order id strings at data.orders[], FastSpring: List Products returns path strings at data.products[], and FastSpring: List Coupons returns coupon path identifiers only, with expansion unsupported on that endpoint. The pattern is list, then fetch: pass the ids to FastSpring: Get Order, FastSpring: Get Product or FastSpring: Get Coupon, each of which accepts several ids separated by commas so the second hop can be one call. Two responses are bare top-level arrays instead, so their rows sit at data[]: FastSpring: List Report Jobs and FastSpring: List Subscription Entries.

Subscription changes, and the preview that makes them safe

FastSpring: Update Subscription changes a live subscription's product, quantity, price, discount, add-ons, coupons, next charge date, end date or renewal mode. With prorate set to true FastSpring calculates and invoices the difference immediately, which is why the node is flagged destructive. Run it with preview set to true first: that returns the prorated charges and credits without committing anything, which is the number to put in front of a person or a condition. For stopping billing, the choice matters. FastSpring: Pause Subscription schedules a pause on the next billing cycle date and charges nothing at execution, and FastSpring: Resume Subscription is its counterpart, with the caveat that resuming charges the customer immediately and starts a new cycle. FastSpring: Cancel Subscription ends the subscription at the end of the current billing period by default, or immediately when billing_period is 0. FastSpring: Uncancel Subscription is a genuine undo, reported back through FastSpring's subscription.uncanceled webhook, but only while the deactivation has not yet landed.

Coupons: additive codes versus replaced codes

FastSpring: Create or Update Coupon writes the discount, the products it targets, its active dates and its redemption limit, and FastSpring decides create or update from whether the coupon path already exists. The trap is the codes array: sending it on an update REPLACES every existing code. Leave it blank to keep them and use FastSpring: Add Coupon Codes, which appends, stores codes uppercase, and deduplicates case insensitively. Read the stored state back with FastSpring: List Coupon Codes rather than assuming, and use that node instead of FastSpring: Get Coupon past 1,000 codes, which is where the single-coupon read stops. Retiring a campaign has a reversible option and a permanent one: set the coupon's available end date in the past to stop it quietly, or run FastSpring: Delete All Coupon Codes and then FastSpring: Delete Coupon, in that order, permanently.

Refunds and the account portal link

FastSpring: Create Return refunds an order in full or in part. Real money goes back to the buyer, product access tied to the order is returned, and with notification set to ORIGINAL the buyer is emailed. There is no un-return, and there is no idempotency header on these endpoints, so retry logic belongs in your workflow rather than in hope: put the node behind an approval task and let one branch reach it. FastSpring: Get Return reads the result, with rows inside a returns array at data.returns[0]. One neighbouring node deserves the same caution for a different reason: FastSpring: Get Account Management URL mints an authenticated, expiring link into the customer's own portal, so anyone holding it is signed in as that customer. It is classed as a write despite being a GET. Send it to the account owner and nowhere else.

Checkout sessions, accounts and price previews

The pre-purchase side of the store is here too, and none of it moves money. FastSpring: Create Account makes a customer record a later checkout or subscription can attach to, and FastSpring recommends including the customer's country, because some payment methods require it and transactions can otherwise fail; FastSpring: Update Account changes only the fields you fill, though email is required on the call either way, since FastSpring's update schema lists it as a required field. FastSpring: Create Checkout Session builds a session with the cart and customer already filled in and returns everything you need in one response, including calculated totals and the checkout URL to send the shopper to, and FastSpring: Get Checkout Session reads its state and any outstanding requirements later. A session is an intent rather than a transaction: nothing is charged until the shopper completes the page, and an abandoned session expires. For the numbers a quote or a pricing page needs, FastSpring: List Product Prices returns localized prices for every product keyed by country, FastSpring: Get Product Price narrows to one, FastSpring: Preview Product Tax estimates indirect taxes before any checkout exists, and FastSpring: Get Product Offers lists the add-ons, cross-sells and upgrades attached to a product. Catalog writes go through FastSpring: Create or Update Products, which takes a JSON array and decides create or update per product path.

Event recovery instead of a trigger

This integration is the API side of FastSpring, so it has no trigger nodes; what it has is the recovery path, which is arguably more useful when an endpoint has an outage. FastSpring: List Unprocessed Events returns every event FastSpring has not seen acknowledged, each with its id, type, created timestamp and full payload, and FastSpring: Update Event marks one handled. FastSpring: List Processed Events is the audit side of the same ledger. FastSpring keeps events for 30 days and returns nothing older, so a scheduled sweep should run well inside that window. When signing secrets rotate, FastSpring: Update Webhook Key Secret does it, and the sequencing rule is on the node: make the receiving server able to verify the new secret first, because every delivery after the call is signed with it.

Reporting, and how to get one row per day

FastSpring: Generate Subscription Report returns the metrics behind FastSpring's Subscription Overview: activations, cancellations, MRR movement, subscriber counts, churn ratios and lifetime value over a date range. One configuration detail decides whether the output is a time series or a single aggregate. FastSpring's reference offers occurred_date in both the report columns and the grouping without stating a rule that ties them together; in practice, through the connector, it has to be in BOTH before you get one row per day. Request neither and the rows are undated; request the column without the grouping and they are not per day. Keep async_job false and the rows arrive inline in the response's report array, which the connector surfaces at data.report[]; set it true and FastSpring returns a job stub instead, notifying any addresses you listed, and you collect the result with FastSpring: Get Report Job and FastSpring: Download Report. FastSpring: Generate Revenue Report is the transaction level equivalent, where the bucket width is whatever you group by. When storing these rows, remember that the cumulative columns are gauges rather than per-period flows, and the trailing ratios cannot be recombined across windows: request the window you actually want.

What stays off the canvas

Several documented FastSpring surfaces are deliberately absent, each for a reason. Quotes and the digital invoicing built on them are a single workflow, and shipping only the read half would surface a resource nobody could act on. The v1 sessions API is labelled legacy by FastSpring, so the integration builds v2 instead, and within v2 it ships create and retrieve rather than the incremental cart-editing endpoints, which exist for interactive front ends holding a live session rather than for a workflow step. Co-term group management, cancel surveys, subscription transfer and convert, product offer writes, the operational cache reset, and webhook replay are all out of scope for this version. Subscription plan-change previews are covered by the preview flag on FastSpring: Update Subscription.

Troubleshooting

Test Connection fails with a 401 error
FastSpring returns 401 when HTTP Basic does not carry a valid API credential set, so a failure here is about the credential itself. The most common cause is a mismatched pair: the username belongs to the credential set, not to your FastSpring login, and both halves must come from the same set. Check for leading or trailing whitespace from the copy, and confirm the credential was not regenerated in the FastSpring app after you saved it, which invalidates the old password immediately. Re-create the set under Developer Tools, then APIs, then API Credentials, and update the credential in Connectors.
A node reports success but nothing changed in the store
Several FastSpring endpoints return validation failures as HTTP 200 with a result of error in the body. The coupons endpoints document this outright, telling callers to check the result field rather than relying on the HTTP status alone, and routine payment declines behave the same way. The connector's success flag follows the HTTP status, so add a condition on data.result before a downstream step treats the operation as done. On FastSpring: Charge Managed Subscription the flag to read is the per subscription one at data.subscriptions[0].result; HTTP 400 on that node is reserved for a hard decline or a subscription past its retry limit.
A downstream template is empty because a list returned strings
That is FastSpring's documented shape, not a fault. FastSpring: List Orders returns order ID strings at data.orders[], FastSpring: List Products returns path strings at data.products[], and FastSpring: List Coupons returns coupon path identifiers only, with expansion explicitly unsupported on that endpoint. A template written for data.orders[].id will therefore resolve to nothing. Read the string rows directly, then fetch details with FastSpring: Get Order, FastSpring: Get Product or FastSpring: Get Coupon, each of which accepts several ids separated by commas. The two bare-array responses, FastSpring: List Report Jobs and FastSpring: List Subscription Entries, put their rows at data[] instead.
List Accounts returns ids one run and richer rows another
FastSpring documents that GET /accounts returns an array of account IDs when no parameters are sent, and its response schema describes that field only as an array of account IDs. It does not document a parameter-driven switch to a fuller record, so do not build on one. FastSpring: List Accounts sends nothing by default, so the id-string shape is the one to build against, and its description says so. Whatever filters you add for email, lookup key, order, subscription or product, branch on the row type rather than assuming: check whether the row is a string before reading a field off it, and fetch the record itself with FastSpring: Get Account when you need its contents. FastSpring: List Subscriptions always sends a limit and in practice returns full objects, which is one more reason to type-check each lister rather than generalise a shape rule across them.
Delete Coupon is refused while the coupon still has codes
FastSpring will not delete a coupon that still has active codes, so the two nodes form a required sequence: run FastSpring: Delete All Coupon Codes first, then FastSpring: Delete Coupon. Both are permanent and both are flagged destructive, and the pair is one-way, since neither the codes nor the coupon can be restored afterwards. If the campaign might return, do not delete it at all: set the coupon's available end date in the past with FastSpring: Create or Update Coupon, which stops it applying at checkout while leaving the configuration and its codes intact.
Resuming a paused subscription charged the customer
That is the documented behaviour and the reason the node is flagged destructive despite its name. When you cancel an upcoming pause, FastSpring charges the customer immediately and starts a new billing cycle, so FastSpring: Resume Subscription is a money-moving call rather than a state toggle. There is no way to resume without the charge. Build for it: put the node behind the same gating as the refund and charge nodes, tell the customer before it runs if the timing is unexpected for them, and use FastSpring: Get Subscription first to confirm there really is a pause scheduled and the state is what you assumed.
The subscription report has no per-day rows
The date grain on that report is a function of the columns and grouping you request, not of the window. FastSpring's reference offers occurred_date in both lists without documenting a rule that connects them, but in practice, through the connector, it has to be in BOTH report_columns and group_by on FastSpring: Generate Subscription Report: request neither and you get an undated aggregate for the whole range, and request the column without the grouping and the rows are not per day. Keep async_job false as well, because FastSpring documents that an asynchronous request returns a job stub, and a stub carries no rows at all. If a returned window looks clipped rather than aggregated, compare the row count against page_count before storing it, since a clipped window saved as a whole one is the error that will not announce itself.
A downloaded report is cut off
FastSpring: Download Report returns CSV text rather than JSON. FastSpring returns the file itself; the fields around it are the Mattering connector's, which wraps any text response as data.content with a data.length and a data.truncated flag alongside it. The cut-off is the connector's own text cap rather than a FastSpring limit, and the connector setting truncated to true is the signal that you are looking at part of a file. When it appears, page the report by requesting narrower date windows from FastSpring: Generate Subscription Report or FastSpring: Generate Revenue Report and downloading each job separately, rather than raising the window and hoping. Check the flag before parsing, because a truncated CSV parses perfectly well and simply contains fewer rows than the report has.

FastSpring is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.

Start Free Explore our Products