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.

TypeRoleDescription
outgoingrequesterYou open the case with another bank. Mambu Payments sends a camt.110 message.
incomingresponderAnother bank opens the case with you. Mambu Payments receives a camt.110 message.
internalresponderYou 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_roleDescription
subjectThe payment that the case investigates.
follow_upA side operation on the subject, such as a return or a claim.
evidenceAn object that supports the case, such as another payment.
relatedAny 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.

categoryinvestigation_typeinvestigation_sub_typeUse
claim_non_receiptCCNR–The creditor did not receive the funds.
claim_non_receiptCONR–The creditor agent did not receive the cover payment.
unable_to_applyUTAP–A bank received funds but cannot apply them.
request_for_informationRQFIUTEXA bank cannot execute a payment and needs more information.
compliance_screeningRQFISANCA sanctions screening needs more information.
compliance_screeningRQFIAMLI, FRAD, FCCI, or FWTRAn 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:

  1. Identify the payment order or incoming payment to investigate.
  2. Generate a UUID v4 for the investigation_request.eir field. Each eir can be used only once.
  3. Send the request with type set to outgoing.

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.

StatusDescriptionNext status
processingMambu is building and sending the camt.110 message.pending_response, resolved, rejected, canceled
pending_responseSwift acknowledged the request. The responder has not closed the case.resolved, rejected, canceled
resolvedThe responder closed the case with an answer.pending_response, closed
rejectedSwift or the responder rejected the case.pending_response, closed
canceledThe requester withdrew the case.closed
closedYou 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.110 message that opened the case, while the case is processing.
  • Swift sends a trck.003 (Tracker Alert Notification) message with the RJIN status for that camt.110, while the case is processing or pending_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 statusCase statusMeaning
PDNGUnchangedThe responder is working on the case. Mambu Payments triggers the case.pending event.
CLSDresolvedThe responder closed the case with an answer.
RJCTrejectedThe 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.

EndpointActionCase effectEvent
POST /v1/cases/<case_id>/status_requestAsk the responder for a status update.Nonecase.status_requested
POST /v1/cases/<case_id>/cancelWithdraw the case.canceledcase.canceled
POST /v1/cases/<case_id>/objectObject to the answer and reopen the case.pending_responsecase.pending_response
POST /v1/cases/<case_id>/closeArchive the case.closedcase.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 actionCase 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_codeCase effectUse
PDNGNone. Mambu Payments triggers a pending event.Tell the requester that you are working on the case.
CLSDpending_action to resolvedClose the case with an answer.
RJCTpending_action to rejectedDecline the case.

The required fields in data for a CLSD answer depend on the investigation type of the case.

investigation_typeRequired fieldDescription
CCNR, CONRconfirmationThe amount, currency, debit or credit indicator, and value date of the payment.
RQFI, UTAPtransaction_data or response_narrativeThe 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>/respond with a closing response moves the case to resolved. PDNG and RJCT are not accepted on an internal case.
  • POST /v1/cases/<case_id>/cancel moves the case to canceled.
  • POST /v1/cases/<case_id>/object reopens a resolved case.
  • POST /v1/cases/<case_id>/close moves a resolved or canceled case to closed.

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/cases lists cases, filtered by status, category, type, eir, original_uetr, related_object_id and more.
  • POST /v1/cases/<case_id> updates metadata and related_objects, for example to link a payment that Mambu Payments could not match. It triggers the case.updated event.

Did this page help you?