Swift case management
A case is a structured investigation about a cross-border payment that you open with or receive from another bank through Swift.
This guide supplements but does not replace the Swift documentation for case management and the ISO 20022 investigation message usage guidelines. Scheme rules are maintained by Swift and are subject to change. Refer to the official Swift documentation for definitive requirements.
How it works
Use cases to open an investigation, answer one, and track its status.
When you open an outgoing case, Mambu Payments creates a camt.110 (Investigation Request) message and sends it to the Swift case manager that then routes it to the responder bank. The responder answers with a camt.111 (Investigation Response) message that Mambu Payments uses to update the case.
When another bank opens a case with you, the flow runs in reverse. Mambu creates an incoming case and links it to the matching payment, when it finds one.
Key concepts
Case
A case is the Mambu Payments object that represents one investigation. Every case has a type, a role, a status, a category, and usually one or more related objects.
| Type | Role | Description |
|---|---|---|
outgoing | requester | You open the case with another bank. Mambu Payments sends a camt.110 message. |
incoming | responder | Another bank opens the case with you. Mambu Payments receives a camt.110 message. |
internal | responder | You track an investigation inside your organisation. Mambu Payments sends no Swift message. |
Investigation request and response
The investigation_request object holds what the requester asks. It includes the investigation reference (eir), the BICs of both banks, the investigation type, and the reference of the original payment. The investigation_responses list holds the answers, one entry per final answer (CLSD or RJCT), oldest first. Mambu Payments fills it from the camt.111 messages you receive or send.
The eir is a UUID v4 that identifies the investigation. Swift uses it to bind every message to its case.
Related objects
A related object links a case to a payment order or an incoming payment. Each link has a link_role that states how the object relates to the case.
link_role | Description |
|---|---|
subject | The payment that the case investigates. |
follow_up | A side operation on the subject, such as a return or a claim. |
evidence | An object that supports the case, such as another payment. |
related | Any other connected object, such as a duplicate payment. |
Mambu Payments sets match_source to auto when it links an object from the original payment's unique end-to-end transaction reference (UETR). It sets match_source to manual when you add the link.
Investigation types
Open outgoing cases with these investigation types. You don't send category on an outgoing case: Mambu Payments derives it from investigation_type and investigation_sub_type as shown below, and rejects a request that carries one.
category | investigation_type | investigation_sub_type | Use |
|---|---|---|---|
claim_non_receipt | CCNR | – | The creditor did not receive the funds. |
claim_non_receipt | CONR | – | The creditor agent did not receive the cover payment. |
unable_to_apply | UTAP | – | A bank received funds but cannot apply them. |
request_for_information | RQFI | UTEX | A bank cannot execute a payment and needs more information. |
compliance_screening | RQFI | SANC | A sanctions screening needs more information. |
compliance_screening | RQFI | AMLI, FRAD, FCCI, or FWTR | An anti-money laundering, fraud, financial crime, or wire transfer regulation check needs more information. |
Mambu Payments currently does not support the OTHR investigation type for outgoing cases. This excludes the request_to_return, request_to_modify, value_date_adjustment, charges_query, and other categories for the Swift channel.
Service level
The service_level sets the response time that you request from the responder. Use R01D, R03D, R05D, R10D, or R15D. For example, R05D requests an answer within five days.
Outgoing cases
Open an outgoing case
To investigate a payment that you sent, create an outgoing case with POST /v1/cases on a connected account that has the case_management bank service:
- Identify the payment order or incoming payment to investigate.
- Generate a UUID v4 for the
investigation_request.eirfield. Eacheircan be used only once. - Send the request with
typeset tooutgoing.
The following request opens a claim of non-receipt for a €90.00 cross-border payment. The original_settlement_amount is in minor units, so 9000 equals €90.00.
{
"connected_account_id": "0b84e2e6-a321-42cc-9539-79b60005b545",
"type": "outgoing",
"subject": "Claim of non-receipt – invoice 2026-0417",
"description": "The beneficiary reports that the payment of 4 November has not arrived.",
"priority": "high",
"related_objects": [
{
"related_object_type": "payment_order",
"related_object_id": "4791e2ea-416c-4254-a09d-e195f7178137",
"link_role": "subject"
}
],
"investigation_request": {
"eir": "0b84e2e6-a321-42cc-9539-79b600050001",
"responder_bic": "ETETBETAXXX",
"responder_dn": "ou=payments,o=etetbeta,o=swift",
"investigation_type": "CCNR",
"underlying_instrument": "XBCT",
"service_level": "R05D",
"underlying": {
"original_uetr": "fff0e2e0-de67-402e-bb4b-eca40713a479",
"original_settlement_amount": 9000,
"original_settlement_currency": "EUR",
"original_settlement_date": "2026-11-04"
},
"data": [
{
"reason_code": "CCNR"
}
]
},
"metadata": {}
}The API returns the case with status set to processing.
{
"id": "c1d9a7f2-5e43-4a0b-b6d1-9a2f6c8e1b37",
"object": "case",
"connected_account_id": "0b84e2e6-a321-42cc-9539-79b60005b545",
"type": "outgoing",
"role": "requester",
"status": "processing",
"status_details": null,
"subject": "Claim of non-receipt – invoice 2026-0417",
"priority": "high",
"category": "claim_non_receipt",
"created_at": "2026-11-04T09:08:17.734182Z"
}The response above shows the main fields. The full object also returns description, related_objects, investigation_request, investigation_responses, bank_data, and metadata.
Mambu Payments sends the camt.110 message with the connected account's next scheduled file generation. The status changes when Swift acknowledges or rejects the message.
Track an outgoing case
Mambu Payments updates the case status as Swift and the responder answer. Subscribe to case events to follow each change.
| Status | Description | Next status |
|---|---|---|
processing | Mambu is building and sending the camt.110 message. | pending_response, resolved, rejected, canceled |
pending_response | Swift acknowledged the request. The responder has not closed the case. | resolved, rejected, canceled |
resolved | The responder closed the case with an answer. | pending_response, closed |
rejected | Swift or the responder rejected the case. | pending_response, closed |
canceled | The requester withdrew the case. | closed |
closed | You archived the case. | – |
The responder's answer can arrive before Swift's acknowledgement, so a case can move from processing straight to resolved or rejected.
Mambu Payments moves the case to rejected in these situations:
- Swift sends a negative acknowledgement (NAK) for the
camt.110message that opened the case, while the case isprocessing. - Swift sends a
trck.003(Tracker Alert Notification) message with theRJINstatus for thatcamt.110, while the case isprocessingorpending_response.
In both situations, Mambu saves the rejection reason and any additional information in status_details. A NAK on a follow-up message leaves the status unchanged.
The responder answers with a camt.111 message. Mambu Payments matches it to your case by its eir. The status in the response sets the case status.
camt.111 status | Case status | Meaning |
|---|---|---|
PDNG | Unchanged | The responder is working on the case. Mambu Payments triggers the case.pending event. |
CLSD | resolved | The responder closed the case with an answer. |
RJCT | rejected | The responder declined the case. |
Mambu Payments also adds each CLSD or RJCT answer to the investigation_responses list. Read the confirmation details, transaction data, and narrative from this list.
Follow up on an outgoing case
Use these endpoints to act on a case after you open it. Mambu sends a follow-up camt.110 message for each action except close, once the opening camt.110 has been sent. A case canceled before that is canceled without any message.
| Endpoint | Action | Case effect | Event |
|---|---|---|---|
POST /v1/cases/<case_id>/status_request | Ask the responder for a status update. | None | case.status_requested |
POST /v1/cases/<case_id>/cancel | Withdraw the case. | canceled | case.canceled |
POST /v1/cases/<case_id>/object | Object to the answer and reopen the case. | pending_response | case.pending_response |
POST /v1/cases/<case_id>/close | Archive the case. | closed | case.closed |
Send cancel while the case is processing or pending_response. Send object when the case is resolved or rejected, once the responder has answered it. Send close when the case is resolved, rejected, or canceled. Send status_request when the case is pending_response.
Cancel and object require a reason, such as NARR with an explanation in additional_information.
To remind the responder, send a status request with an explanation.
{
"additional_information": "Reminder 1 – the beneficiary is still waiting for the funds."
}When Swift forwards a reminder that the case manager generated, Mambu triggers the case.reminder_received event. The case status does not change.
Incoming cases
Receive an incoming case
When another bank opens a case with you, Mambu Payments creates a case without any action from you. The case has type set to incoming, role set to responder, and status set to pending_action.
Mambu Payments links the case to the payment that exactly matches the original UETR on your connected account. If there is no match, or more than one, Mambu still opens the case in pending_action, and you can link the payment with POST /v1/cases/<case_id>.
Mambu triggers the case.pending_action event when it creates the case.
The requester can send follow-up messages that update an existing case.
| Requester action | Case effect |
|---|---|
Cancel (RQCL) | The case moves to canceled if it is pending_action. Once you have answered or closed the case, nothing changes. |
Object (RQOB) | The case moves back to pending_action. |
Status request (RQST) | The case stays in its status. Mambu triggers the case.status_requested event. |
Mambu matches a follow-up message to the case using the eir. If no case has that eir, Mambu opens the case from the follow-up and then applies its action.
Respond to an incoming case
To answer an incoming case, send POST /v1/cases/<case_id>/respond while the case is pending_action. Mambu builds a camt.111 message and sends it to the requester.
The status_code sets the answer.
status_code | Case effect | Use |
|---|---|---|
PDNG | None. Mambu Payments triggers a pending event. | Tell the requester that you are working on the case. |
CLSD | pending_action to resolved | Close the case with an answer. |
RJCT | pending_action to rejected | Decline the case. |
The required fields in data for a CLSD answer depend on the investigation type of the case.
investigation_type | Required field | Description |
|---|---|---|
CCNR, CONR | confirmation | The amount, currency, debit or credit indicator, and value date of the payment. |
RQFI, UTAP | transaction_data or response_narrative | The information that the requester asked for. Provide at least one of the two fields. |
The following request closes a claim of non-receipt and confirms that the funds were credited.
{
"status_code": "CLSD",
"status_reason_code": "CAPR",
"data": [
{
"confirmation": {
"amount": 9000,
"currency": "EUR",
"debit_credit_indicator": "CRDT",
"value_date": "2026-11-05"
}
}
]
}The API returns the case with status set to resolved.
To reopen a resolved, rejected, canceled, or closed incoming case, the requester sends an object message. Mambu Payments moves the case back to pending_action, and you respond again.
Internal cases
To track an investigation that stays inside your organisation, create a case with type set to internal. Mambu Payments creates the case in pending_action and sends no Swift message. An internal case requires a category and no investigation_request.
Move an internal case through its lifecycle with the same endpoints as other cases:
POST /v1/cases/<case_id>/respondwith a closing response moves the case toresolved.PDNGandRJCTare not accepted on an internal case.POST /v1/cases/<case_id>/cancelmoves the case tocanceled.POST /v1/cases/<case_id>/objectreopens aresolvedcase.POST /v1/cases/<case_id>/closemoves aresolvedorcanceledcase toclosed.
Share text with the other bank
Comments and attachments are not available on cases yet. To share short text with the other bank, use investigation_request.data[].additional_information on a request (up to 500 characters), or response_narrative on a response (up to 140 characters).
Find and update cases
GET /v1/cases/<case_id>returns a case.GET /v1/caseslists cases, filtered bystatus,category,type,eir,original_uetr,related_object_idand more.POST /v1/cases/<case_id>updatesmetadataandrelated_objects, for example to link a payment that Mambu Payments could not match. It triggers thecase.updatedevent.
Updated about 5 hours ago
