Fortis doesn't natively connect to Twilio for voice payments. If you want to process Fortis transactions during a phone call (via IVR, agent-assisted, or AI voice agent), you need a Twilio Pay Connector that bridges the two platforms.
Shuttle's Pay Connector does exactly this. It connects Fortis (and 30+ other gateways) to Twilio's <Pay> verb, so you can accept PCI-compliant card payments during any voice interaction.
This guide walks through how the integration works, how to set it up, and what to watch for.
Why Fortis + Twilio Don't Connect Directly
Fortis is an embedded payments platform built for ISVs and B2B software. Its APIs and plugins put payment processing inside the software businesses already run: ERP and accounting platforms like Sage, NetSuite and Acumatica, healthcare practice management systems, and other vertical B2B tools. Tokenisation, recurring billing, and click-to-pay invoicing are core to the platform.
Twilio is built for voice and messaging. Its <Pay> verb captures card details during phone calls via DTMF keypad input, with tones suppressed so agents never hear them.
The problem: Twilio's <Pay> needs a Pay Connector to route captured card data to a payment gateway. Fortis isn't one of Twilio's built-in connectors, so there is no native path between the two.
This is where Shuttle comes in. As Twilio's official payment partner, Shuttle provides a Pay Connector that accepts card data from Twilio's <Pay> verb and routes it to Fortis for processing. One integration connects the two platforms.
For an ISV or B2B platform that already embeds Fortis, this adds a phone channel without touching the existing payment stack: accounts receivable teams can take a card on a follow-up call, field service businesses can collect deposits by phone, and healthcare providers can settle patient balances during a billing call.
How It Works
`` Caller → Twilio (DTMF capture) → Shuttle (Pay Connector) → Fortis (processing) → Result ``
Caller reaches payment step. Your Twilio call flow (IVR or custom TwiML) triggers the
<Pay>verb.Card details captured via DTMF. The caller enters their card number, expiry, and CVV on the keypad. Tones are suppressed from the agent audio and call recordings.
Shuttle receives card data. The data passes from Twilio's PCI-compliant environment directly to Shuttle's connector. It never touches your servers.
Shuttle charges the card via Fortis. The connector creates a Fortis transaction, processes it through your Fortis merchant account, and handles the response.
Result returned to your call flow. Your webhook receives the Fortis transaction reference, last four digits, card brand, and transaction status. The call continues.
The entire flow happens in seconds. The caller stays on the line. No redirects, no "please visit our website."
Step-by-Step Setup
Prerequisites
A Twilio account with voice capability
A Fortis account with API credentials
A Shuttle account (free to create, you pay per transaction)
Step 1: Install Shuttle's Pay Connector
Go to the Twilio Marketplace and install the Shuttle Pay Connector. This adds Shuttle as an available connector in your Twilio account's Pay configuration.
Step 2: Add Fortis Credentials to Shuttle
Log into the Shuttle dashboard. Navigate to Payment Profiles and create a new profile:
Gateway: Fortis
Credentials: Your Fortis API credentials
Currency: Set your default (USD, etc.)
Environment: Live or Test
Save the profile. Shuttle now has a live connection to your Fortis account.
Step 3: Configure Your Twilio Call Flow
Add the <Pay> verb to your TwiML:
``xml <Response> <Say>Please enter your card number followed by the hash key.</Say> <Pay paymentConnector="shuttle-pay-connector" chargeAmount="149.00" currency="USD" description="Invoice payment" action="/payment-complete"> </Pay> </Response> ``
Key parameters:
paymentConnector: set toshuttle-pay-connectorchargeAmount: the amount to chargecurrency: ISO currency codeaction: your webhook endpoint for the payment result
Step 4: Handle the Payment Result
Twilio sends a POST to your action URL with the payment result:
``json { "Result": "success", "PaymentCardNumber": "xxxx-xxxx-xxxx-1234", "PaymentCardType": "visa", "PaymentConfirmationCode": "FORTIS-TXN-REF-123...", "ProfileId": "your-shuttle-profile-id" } ``
Use the PaymentConfirmationCode to look up the transaction in Fortis if needed. Update your invoice or order record, confirm to the caller, and continue the flow.
Step 5: Test
Use Fortis's test environment and Twilio's test credentials to verify the flow end-to-end before going live. Run a full test transaction and confirm the result lands in both your webhook and your Fortis reporting.
What You Can Do With Fortis + Twilio
Charge Immediately
Standard auth-and-capture. The caller pays, Fortis processes, done. For AR teams chasing overdue invoices by phone, this turns a promise-to-pay into a settled payment on the same call.
Authorise Now, Capture Later
Place a hold on the card during the call and capture later. Useful for deposits, work orders with a variable final amount, or bookings that need confirmation before billing.
Tokenise for Future Use
Capture card details once over the phone. Shuttle tokenises the card and returns a reusable token. Use it for future payments across any channel: web, mobile, voice, or payment links. This suits recurring B2B billing and healthcare payment plans, and the card data is never stored in your systems.
Add Voice to an Embedded Payments Stack
If you're an ISV that embeds Fortis in your ERP, accounting, or healthcare software, the phone channel plugs into the same merchant relationship. Your users take payments in-app through Fortis and over the phone through Twilio, and both land in the same place. See payments for ERP platforms for how platforms structure this.
Multi-PSP: Beyond Fortis
One of the key advantages of using Shuttle rather than a single-gateway connector is flexibility. Your Twilio integration stays the same even if you:
Add a second gateway: route US transactions to Fortis and international transactions to a local acquirer
**Serve enterprise customers** who mandate a specific PSP (Stripe, Worldpay, Checkout.com, etc.)
Need failover: if one gateway has an outage, automatically route to a backup
Expand to new markets where a different acquirer gives better authorisation rates
You configure routing rules in Shuttle's dashboard. Your Twilio call flow doesn't change. The <Pay> verb always points to shuttle-pay-connector, and Shuttle handles which gateway processes the transaction.
This is particularly important for platforms and BPOs that serve multiple merchants. Each merchant can use their own Fortis account (or any other gateway) through the same Twilio integration.
PCI Compliance
The Fortis + Twilio integration via Shuttle keeps you completely out of PCI scope:
Layer | PCI handled by |
|---|---|
DTMF capture & suppression | Twilio |
Card data processing | Shuttle (PCI DSS Level 1) |
Payment processing | Fortis |
Your systems | No card data: SAQ-A |
Card data flows from Twilio to Shuttle to Fortis. Your application only receives redacted data (last 4 digits, card brand, transaction reference). You qualify for SAQ-A, the lightest PCI self-assessment. For healthcare software, this matters twice over: card data stays out of the same systems that hold patient records.
For the full picture on PCI compliance with Twilio, see Twilio PCI Compliance: Payments Without Handling Card Data.
FAQ
Can I connect Fortis to Twilio without Shuttle? Twilio doesn't have a built-in Fortis Pay Connector. You'd need to build a custom connector using Twilio's Generic Pay Connector framework, which means handling PCI compliance for card data processing yourself. Shuttle provides a pre-built, PCI-certified connector that handles this.
I'm an ISV that embeds Fortis. Does this work for my merchants? Yes. Each merchant's payment profile in Shuttle points to their own Fortis account, so voice payments settle alongside their existing in-app transactions. One Twilio integration serves all of them.
Does tokenisation work over the phone? Yes. Cards captured via Twilio's <Pay> verb can be tokenised through Shuttle for reuse across web, mobile, voice, and payment links, which supports recurring billing without your systems ever holding card data.
What about Fortis's test environment? Fully supported. Use your Fortis test credentials in Shuttle and test the full flow with Twilio before going live.
What does it cost? Shuttle charges $0.20 per successful transaction. Fortis's processing fees apply on top per your agreement. No Shuttle setup fees or monthly minimums.
Can I switch from Fortis to another gateway later? Yes. Change the gateway in your Shuttle payment profile. Your Twilio call flow stays exactly the same, no code changes needed.
Related Reading
Twilio Pay Connectors: How to Connect Any Payment Gateway: the complete guide to Twilio Pay Connectors and multi-PSP routing
Twilio PCI Compliance: Payments Without Handling Card Data: how to keep your PCI scope at SAQ-A
How to Connect Stripe to Twilio for Voice Payments: step-by-step Stripe + Twilio setup
How to Connect Adyen to Twilio for Voice & IVR Payments: step-by-step Adyen + Twilio setup
Payments for ERP Platforms: embedding payment collection inside ERP and accounting software
Payment Collection for BPOs: multi-client payment routing for outsourced contact centres
Twilio Pay: Connect Any Payment Gateway to Twilio: all supported gateways, pricing, and setup
*Connect Fortis to Twilio in minutes with Shuttle's Pay Connector: PCI DSS Level 1, $0.20/transaction, no setup fees. Install on Twilio or book a discovery call.*