Appian Adapter for Swift Overview

What is the Appian adapter for Swift?

Swift message processing involves receiving messages from various channels, validating them according to relevant standards, and routing them to other systems based on their intended purpose. Managing this manually or across disconnected tools introduces delays, data errors, and limited visibility into transaction status.

What if you could simplify how your systems interact with the Swift network?

Built on the Appian process automation platform, the Appian adapter for Swift validates, converts, and routes inbound and outbound Swift MT and MX messages. The adapter leverages the Prowide open-source libraries to parse and serialize messages according to the Swift MT (Message Type, ISO 15022) and MX (ISO 20022 XML) standards, and uses the Prowide Integrator Validation module to enforce Swift network syntactic formatting and semantic rules.

Messages flow in and out through configurable upstream channels, while direct API integrations with Swift Case Management, a Swift-hosted platform for managing payment investigation cases and exceptions across the Swift network, enable real-time transaction tracking and automated exception handling, leveraging data from the Swift gpi Tracker. The adapter is deployed as-is. To process messages for your organization's specific workflows, build downstream applications, and configure the provided integration objects to connect them to the adapter.

For details on the Swift messaging standards, see the Swift Standards documentation. For details on the Prowide libraries, see the Prowide open-source project.

Appian adapter for Swift use case

The following example illustrates how an organization can use the Appian adapter for Swift with a downstream application such as a payment investigation system.

Global Bank processes thousands of Swift messages daily. When the bank receives an inbound MT103 customer credit transfer from a correspondent bank via the Swift network, the transaction follows this sequence:

1. Arrival: The MT103 message arrives through the bank's configured upstream channel.
2. Validation: The adapter automatically validates the MT103 message against Swift network rules.
3. Conversion: The adapter parses the message and converts the message into a structured Appian data object.
4. Routing: The adapter routes the structured Appian data object and any logged validations to a configured downstream application, such as the bank's payment investigation system.

After the downstream application receives the structured Appian data object, the application processes the object using one of the following methods:

• Straight-through-processing: If the data object meets specific criteria, then the application processes the data object automatically.
• Manual review: If the data object requires intervention, then a payment investigator manually reviews and reconciles the message.

Later, an analyst reviewing an investigation determines that a charges notification needs to be sent. The analyst triggers an adjustment from the downstream application, which sends an Appian data object with the collected data to the adapter. The adapter converts it into a camt.105 (ChargesPaymentNotification), validates it, and sends it to the appropriate channel to reach the Swift network.

In another scenario, the bank needs to initiate a stop-and-recall request on a transaction that was sent in error. The analyst triggers the request from the downstream application, which sends an Appian data object to the adapter. The adapter converts it into a relevant API request body, validates it, and sends it directly or indirectly through a proxy to the Swift Case Management Stop and Recall API. The adapter then monitors Swift Case Management for status updates, confirming when the receiving bank has processed the stop request and returned the funds, then forwarding this update to the downstream application as an Appian data object.

Appian adapter for Swift capabilities

• Inbound message processing: Receive MT and MX messages from any upstream channel, validate them against Swift network rules, parse and convert them into structured Appian data objects, and route them for downstream processing.
• Outbound message processing: Convert structured Appian data objects into validated Swift MT or MX messages and transmit them to the Swift network via any upstream channel.
• Swift Case Management integration: Create and manage the following transaction investigation cases through the Swift Case Management APIs using ISO 20022 MX messages:
  • Customer Credit Not Received (CCNR).
  • Cover Not Received (CONR).
  • Unable to Apply (UTAP).
  • Request for Information (RQFI).
  • Unable to Execute (UTEX).
  • Request Action.
• Message validation: Validate all inbound and outbound messages using the Prowide Integrator Validation module, which enforces Swift format rules, field-level validation, semantic (network) rules, Business Identifier Code (BIC) and International Bank Account Number (IBAN) validation, and Cross-Border Payments and Reporting Plus (CBPR+) schema validation.
• Exception management: Surface validation errors to users or return them to calling systems for remediation before messages are transmitted.
• Message records and audit trail: Store records for all inbound and outbound Swift messages. Provide historical process auditing of major events.
• Operational reporting dashboard: Monitor Swift message processing volumes and system health from the home page. View total, inbound, outbound, and failed message counts, volume by message type, processing status breakdowns, and failure analysis, filtered by date range.
• Swift gpi Tracker integration: Submit requests to seven Swift gpi Tracker services through a dedicated API endpoint for automated gpi status updates and transaction tracking across the 2025 and 2026 environments.

Appian adapter for Swift user roles

The Appian adapter for Swift defines a single user role:

Swift Message Manager: Can view all inbound and outbound Swift messages, logged validations, and related audit data.

How the Appian adapter for Swift processes messages

The Appian adapter for Swift supports four primary processing workflows:

1. Inbound message processing: Message received via API > validated > parsed and converted to Appian data object > routed to target system.
2. Outbound message processing: Appian data object received via API > converted to MT/MX message > validated > sent to configurable upstream channels.
3. Case Management inbound processing: The adapter polls Swift Case Management regularly via API and receives new requests or case updates > parsed and converted into Appian data object > routed to the target system.
4. Case Management outbound processing: Appian data object received via API > converted to appropriate request body > validated > sent to Swift Case Management API endpoint.

For details on supported message types, see Supported Message Types. For information on configuring integrations, see Set Up the Appian adapter for Swift.

Get started with the Appian adapter for Swift

• Appian adapter for Swift Features: A summary of the adapter's functional scope.
• Appian adapter for Swift Home Page: Monitor message processing volumes, processing status, and failures from the reporting dashboard.
• Install the Appian adapter for Swift: Deploy the adapter in your Appian environment.
• Set Up the Appian adapter for Swift: Configure upstream and downstream integrations, Swift Case Management authentication, and BIC directory ingestion.
• View Swift Messages: Search, filter, and review processed inbound and outbound messages.
• Test Messages in the Sandbox: Run sample messages through the processing pipeline without calling the APIs externally.
• Integrate with SwiftRef for BIC Validation: Maintain the local BIC directory for message validation.
• Perform the Annual Standards Update: Transition to a new Swift Standards Release version.

Feedback