---
name: support-manage-case
title: Managing your IBM Cloud support cases effectively
description: Learn how to manage your IBM Cloud support cases, including tracking progress, updating cases, and managing watchlists for effective issue resolution.
last-updated: 2026-06-30
---

> ## Documentation Index
> The table of contents for this documentation set is at https://cloud.ibm.com/docs/support?format=markdown
> The index for all IBM Cloud docs is at: https://cloud.ibm.com/docs/llms.txt
> Use these files to discover more information as needed.

# Managing your IBM Cloud support cases effectively
{: #managing-support-cases}

Learn how to manage your IBM Cloud support cases, including tracking progress, updating cases, and managing watchlists for effective issue resolution.
{: shortdesc}

To view and manage your support cases, go to the [Manage cases page](https://cloud.ibm.com/unifiedsupport/cases).  If you're a classic infrastructure user, and you don't see a listing of a previous case, click **View classic infrastructure cases**. You can also get a quick view of your 5 most recently updated open cases by typing `case status` in the [IBM Cloud AI assistant](https://cloud.ibm.com/docs/overview?topic=overview-ask-ai-assistant&format=markdown#support-case-status).

You can also view your IBM support cases on the Manage cases page, but they can only be managed in the [IBM support portal](https://www.ibm.com/mysupport/s/){: external}. Access for viewing these cases is controlled in the IBM support portal. For more information about access, see [Managing Your Support Account Access](https://www.ibm.com/mysupport/s/article/Managing-Your-Support-Account-Access?language=en_US){: external}.
{: note}

## Viewing support cases by using the API
{: #viewing-case-api}
{: api}

You can programmatically view a support case by using the API as shown in the following sample request. For more information, see the [Case Management API](https://cloud.ibm.com/docs/apis/case-management#createcase){: external}.

To view a case, see the following samples:

```curl
curl -X GET 'https://support-center.cloud.ibm.com/case-management/v1/cases/{case_number}?fields=number,updated_at,resources' -H 'Authorization: TOKEN' \
```
{: codeblock}
{: curl}

```java
GetCaseOptions getCaseOptions = new GetCaseOptions.Builder()
  .caseNumber(caseNumber)
  .addFields(GetCaseOptions.Fields.DESCRIPTION)
  .addFields(GetCaseOptions.Fields.STATUS)
  .addFields(GetCaseOptions.Fields.SEVERITY)
  .addFields(GetCaseOptions.Fields.CREATED_BY)
  .build();

Response<Case> response = service.getCase(getCaseOptions).execute();
Case xCase = response.getResult();

System.out.println(xCase);
```
{: codeblock}
{: java}

```javascript
const fieldsToReturn = [
  CaseManagementV1.GetCaseConstants.Fields.DESCRIPTION,
  CaseManagementV1.GetCaseConstants.Fields.STATUS,
  CaseManagementV1.GetCaseConstants.Fields.SEVERITY,
  CaseManagementV1.GetCaseConstants.Fields.CREATED_BY,
];

const params = {
  caseNumber: caseNumber,
  fields: fieldsToReturn,
};

caseManagementService.getCase(params)
  .then(res => {
    console.log(JSON.stringify(res.result, null, 2));
  })
  .catch(err => {
    console.warn(err)
  });
```
{: codeblock}
{: javascript}

```python
fields_to_return = [
  GetCaseEnums.Fields.DESCRIPTION,
  GetCaseEnums.Fields.STATUS,
  GetCaseEnums.Fields.SEVERITY,
  GetCaseEnums.Fields.CREATED_BY,
]

case = case_management_service.get_case(
  case_number=case_number,
  fields=fields_to_return
).get_result()

print(json.dumps(case, indent=2))
```
{: codeblock}
{: python}

```go
getCaseOptions := caseManagementService.NewGetCaseOptions(
  caseNumber,
)
getCaseOptions.SetFields([]string{
  casemanagementv1.GetCaseOptionsFieldsDescriptionConst,
  casemanagementv1.GetCaseOptionsFieldsStatusConst,
  casemanagementv1.GetCaseOptionsFieldsSeverityConst,
  casemanagementv1.GetCaseOptionsFieldsCreatedByConst,
})

caseVar, response, err := caseManagementService.GetCase(getCaseOptions)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(caseVar, "", "  ")
fmt.Println(string(b))
```
{: codeblock}
{: go}


## Updating support cases by using the API
{: #updating-case-api}
{: api}

The following sample request shows how to programmatically update a support case. For more information, see the [Case Management API](https://cloud.ibm.com/docs/apis/case-management#createcase){: external}.

```curl
curl -X PUT '/case-management/v1/cases/{case_number}/status' -H 'Authorization: TOKEN' -d '{
  "action": "resolve",
  "comment": "The issue is resolved. Thank you!",
  "resolution_code": 1
}'
```
{: codeblock}
{: curl}

```java
ResolvePayload statusPayloadModel = new ResolvePayload.Builder()
  .action("resolve")
  .comment("The problem has been resolved.")
  .resolutionCode(1)
  .build();
UpdateCaseStatusOptions updateCaseStatusOptions = new UpdateCaseStatusOptions.Builder()
  .caseNumber(caseNumber)
  .statusPayload(statusPayloadModel)
  .build();

Response<Case> response = service.updateCaseStatus(updateCaseStatusOptions).execute();
Case xCase = response.getResult();

System.out.println(xCase);
```
{: codeblock}
{: java}

```javascript
const statusPayloadModel = {
  action: 'resolve',
  comment: 'The problem has been resolved.',
  resolution_code: 1,
};

const params = {
  caseNumber: caseNumber,
  statusPayload: statusPayloadModel,
};

caseManagementService.updateCaseStatus(params)
  .then(res => {
    console.log(JSON.stringify(res.result, null, 2));
  })
  .catch(err => {
    console.warn(err)
  });
```
{: codeblock}
{: javascript}

```python
status_payload_model = {
  'action': 'resolve',
  'comment': 'The problem has been resolved.',
  'resolution_code': 1,
}

case = case_management_service.update_case_status(
  case_number=case_number,
  status_payload=status_payload_model
).get_result()

print(json.dumps(case, indent=2))
```
{: codeblock}
{: python}

```go
statusPayloadModel := &casemanagementv1.ResolvePayload{
  Action:         core.StringPtr("resolve"),
  Comment:        core.StringPtr("The problem has been resolved."),
  ResolutionCode: core.Int64Ptr(int64(1)),
}

updateCaseStatusOptions := caseManagementService.NewUpdateCaseStatusOptions(
  caseNumber,
  statusPayloadModel,
)

caseVar, response, err := caseManagementService.UpdateCaseStatus(updateCaseStatusOptions)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(caseVar, "", "  ")
fmt.Println(string(b))
```
{: codeblock}
{: go}

## Adding comments to support cases by using the API
{: #comment-case-api}
{: api}

The following sample request shows how to programmatically add a comment to a support case. For more information, see the [Case Management API](https://cloud.ibm.com/docs/apis/case-management#createcase){: external}.

```curl
curl -X PUT '/case-management/v1/cases/{case_number}/comments' -H 'Authorization: TOKEN' -d '{
  "comment": "Test comment api"
}'
```
{: codeblock}
{: curl}

```java
AddCommentOptions addCommentOptions = new AddCommentOptions.Builder()
  .caseNumber(caseNumber)
  .comment("This is an example comment.")
  .build();

Response<Comment> response = service.addComment(addCommentOptions).execute();
Comment comment = response.getResult();

System.out.println(comment);
```
{: codeblock}
{: java}

```javascript
const params = {
  caseNumber: caseNumber,
  comment: 'This is an example comment,',
};

caseManagementService.addComment(params)
  .then(res => {
    console.log(JSON.stringify(res.result, null, 2));
  })
  .catch(err => {
    console.warn(err)
  });
```
{: codeblock}
{: javascript}

```python
comment = case_management_service.add_comment(
  case_number=case_number,
  comment='This is an example comment.'
).get_result()

print(json.dumps(comment, indent=2))
```
{: codeblock}
{: python}

```go
addCommentOptions := caseManagementService.NewAddCommentOptions(
  caseNumber,
  "This is an example comment.",
)

comment, response, err := caseManagementService.AddComment(addCommentOptions)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(comment, "", "  ")
fmt.Println(string(b))
```
{: codeblock}
{: go}

## Updating support cases
{: #updating-case}
{: ui}

Select the case number to update the support case. You can add a comment, attach or remove files, add resources, or update the watchlist.
To update your support case, complete the following steps:
1. From the IBM Cloud console menu bar, click the **Help** icon ![Help icon](../icons/help.svg "Help") > **Support center**.
1. Select the support case from the **Recent support cases** tile.
1. Add a comment, then click **Submit**.
1. Optionally, you can update the following fields:
   * Add a user to the watchlist
   * Attach or remove files
   * Add a specific resource for a technical support case

### Adding a CRN to a case comment
{: #add-crn-case}
{: ui}

Adding details about the specific resources related to a support case allows for a more efficient triage, investigation, and resolution. To view and copy a cloud resource name (CRN) to add to a support case, follow these steps:

1. From the IBM Cloud&reg; console, click the Navigation Menu icon ![Navigation Menu icon](../icons/icon_hamburger.svg "Menu") > **Resource list** to view your list of resources.
1. Expand the sections to locate the service instance for which you want to retrieve the CRN.
1. Click the table row. This action opens the resources table side panel, where you can view the CRN.
1. Select **Copy to clipboard** next to the CRN value.
1. Paste the value into a comment in the support case.

## Updating your support case's watchlist
{: #contact-watchlist}
{: ui}

You can update which users in your account can receive notifications about your support case by adding them to the watchlist. Users can be added to the watchlist when [Creating support cases](https://cloud.ibm.com/docs/support?topic=support-open-case&format=markdown) or after the support case is created.
{: shortdesc}

By default, account users don't have access to create, update, search, or view cases. The account owner must provide users with access by assigning an Identity and Access Management (IAM) access policy. For more information, see [Assigning user access for working with support cases](https://cloud.ibm.com/docs/account?topic=account-access&format=markdown#access).

To ensure that users are notified about updates to an existing support case that you created, complete the following steps to add them to the watchlist.

1. From the IBM Cloud console menu bar, click the **Help** icon ![Help icon](../icons/help.svg "Help") > **Support center**.
1. Select the support case from the **Recent support cases** tile.
1. From the Watchlist section, click the **Settings** icon ![Settings icon](../icons/settings.svg "Settings").
1. Select users that are in the account to add to the watchlist.

   Users that are added to the watchlist must be a member of the account in which the case was created. For more information about assigning users access to your account, see [Adding users to your case management access group](https://cloud.ibm.com/docs/account?topic=account-access&interface=ui&format=markdown#iam-managed).
   {: note}

## Support case status types
{: #search-case-status}

When your response to an update in your support case is needed, the status is displayed as `Waiting on client`. If you don't provide a response within seven days, the status is updated to `Resolved`. The case is then closed if there's still no response after seven more days. For a description of each status type, see the following table:

| Status              | Description |
|---------------------|------------|
| New                 | A created case not yet viewed by a support engineer. |
| In progress         | A case that is under review. |
| Waiting on client   | The support engineer has submitted an inquiry on the case that needs the user's response. |
| Resolution provided | The support engineer provided a resolution that the user needs to perform. |
| Resolved            | The support case is considered finished and ready to be closed. |
| Closed              | Case is closed by a support engineer and can't be reopened. |
{: caption="Support case status types" caption-side="top"}

## Escalating support cases
{: #escalation}

With a paid support plan, you can use the escalation process to surface critical issues and voice your concern about a support case. When a case is escalated, the IBM Cloud support team reviews the information in the support case and responds with appropriate updates. For information about case severity, see [Case severity and initial response times](https://cloud.ibm.com/docs/support?topic=support-support-case-severity&format=markdown).

To escalate a case, complete the following steps:

1. Contact IBM Cloud Support by chat or by phone.
   * Click **Launch AI Assistant** in the [Support Center](https://cloud.ibm.com/unifiedsupport/supportcenter){: external} and type `agent` to connect with a support agent
   * Connect by phone using the number in the [Support Center](https://cloud.ibm.com/unifiedsupport/supportcenter){: external}.
1. Provide your existing case number and a request to escalate the case.
1. Provide the justification an escalation and explain the business impact of your problem or issue.

Basic support plans: If you have a Basic support plan, access to support is through non-technical cases only. If your support inquiry requires a more immediate response, consider upgrading to a Premium or Advanced support plan so you can assign a severity level to a case. To upgrade your support plan, [create a case in the Support Center](https://cloud.ibm.com/docs/support?topic=support-open-case&interface=ui&format=markdown#upgrade-support-plan) or contact an [IBM Cloud Sales](https://www.ibm.com/solutions/cloud?contactmodule){: external} representative for assistance.

## Searching for support cases
{: #search-options}
{: ui}

From the **Manage cases** page, you can filter by case status and search for all of your support cases by using query parameters in the search bar. The default filters are set to view only open cases. To view resolved or closed cases, update the status filter. All parameters can be used together and entered in any order. You can also filter cases by selecting **All cases**, **My cases**, and **Watchlist cases**.

See the following table for details about the search parameters:

| Parameter | Option | Rule |
|-----------|--------|------|
| `number` | target case number | This parameter can't be used with other parameters. When the `number` parameter is used, all of the other parameters and options ignored. The `number` parameter doesn't autofill the search. You must use the whole case number to start the search. |
| `sort` | number  \n subject  \n severity  \n updatedAt | Only one of the `sort` options can be used at one time. You can use the `~` prefix to reverse the sorting order. |
| `status` | new  \n inProgress  \n waitingOnClient  \n resolutionProvided  \n resolved  \n closed | Any number of options can be used. The available options can be entered as `status:new,inProgress` or as `status:new status:inProgress`. |
| `page` | target page to view | If you have several results from your search that spans multiple pages, you can view your results from any result page. For example, to view page 5 out of 10, use `page:5`. |
| `pageSize`  | 10  \n 25  \n 50  \n 100  | The size of that page to be viewed. The page size refers to the number of results that you want to load. |
{: caption="Search query parameters and options" caption-side="top"}

If you enter a term without a parameter, the search results are shown for the support case number and the case subject.
{: note}

### Query and URL examples
{: #search-query-examples}
{: ui}

You can enter search queries in the search bar by stating a parameter and option separated by a colon (:) or you can use parameters in a URL to go directly to a specific case or group of cases on the **Manage cases** page.

To use parameters in the URL, add a question mark (?) to the end of the URL. Then, set your parameter equal to the option you select. You can also separate additional parameters with an ampersand (&).

To search for a case by keyword, you can enter the word in the search bar without a parameter. To search for a keyword with the URL, use `search` as a parameter and set it equal to your keyword, for example, `search=server`.
{: tip}

#### Searching by case number
{: #search-case-number}

Enter the following to search support cases by case number:

Query
:   `number:CS1234567`

URL
:   `https://cloud.ibm.com/unifiedsupport/cases?number=CS1234567`

#### Searching with multiple parameters
{: #search-mult-parameters}

You might want to search for both new and in progress support cases, limit the results to 25 per page, and displayed by severity. You also know that the case that you're looking for isn't going to be within the first couple of pages, so you want to start on page 5. Enter the following search query:

Query
:   `status:new,inProgress page:5 pageSize:25 sort:severity`

URL
:   `https://cloud.ibm.com/unifiedsupport/cases?status=new&status=inProgress&pageSize=25&sort=severity`

#### Searching for resolved cases
{: #search-resolved}

Enter the following query to view all of the resolved cases based on when they were last updated:

Query
:   `sort:~updatedAT status:resolved`

URL
:   `https://cloud.ibm.com/unifiedsupport/cases?sort=~updatedAT&status=resolved`

## Creating and managing case tags
{: #create-case-tags}

You can create and manage custom tags that can be attached to support cases. These tags help categorize cases by service, incident, or any custom logic, making it simpler to search, filter, and manage high volumes of support interactions.

To use tags, the customer's account must have a Premium support tier.
{: important}

### Creating tags in your account
{: #create-tags-account}
{: ui}

Before you can tag cases, you must create tags at the account level. To do so, complete the following steps:

1. Navigate to **Support** > **Manage cases**.
1. Click edit tags to add as many tags as needed. These tags are customizable and can reflect services, incidents, teams, or any other classification relevant to your organization.
1. Click **Save**.

Each tag must be alphanumeric and no longer than 40 characters, and you can attach up to 20 tags to a single support case.
{: note}

### Managing tags in your account
{: #manage-tags-account}

After you create the tags, you can associate them with a case by clicking **Case Tags**, and then remove tags by using the same interface.

To find cases with specific tags, click one or more tags. For example, click `tag100` or `tag100` and `tag102` to view all associated cases.

Only cases that contain all selected tags are displayed, as the search option uses an AND condition. OR filtering is not supported.
{: note}

## Getting notifications for cases opened by using a trusted profile
{: #tp-notifications}
{: ui}

When you are working with a trusted profile and open a support case, you can choose between two options to receive notifications.

Option 1: Notifications can be sent to your email address.

Option 2: Notifications can be sent to the email address associated with the trusted profile.

To use the second option, an email address must be associated with the trusted profile that is not a service ID, cloud resource, or computer resource.
{: note}