> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs-unsw-v6.advance-uac.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs-unsw-v6.advance-uac.com/_mcp/server.

# Say you have supplied what a pending action asked for

POST https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/{id}/pending-actions/{actionId}/resolve
Content-Type: application/json

Marks one of the application's pending actions as resolved, so the assessment team can see you have responded without being told separately.

Send it once you have actually supplied the thing — uploaded the document, sent the qualification, answered the question. Resolving an action does not by itself move any information: it is the signal, not the delivery.

Safe to retry. Resolving an action that is already closed returns it unchanged rather than failing, and leaves the original resolution in place. 404 if the application or action is unknown.

**This does not restart an assessment.** Asking for information does not stop one, so there is nothing waiting to be restarted — the assessor picks the application back up.

Reference: https://docs-unsw-v6.advance-uac.com/unsw-advance-institution-api/applications/say-you-have-supplied-what-a-pending-action-asked-for

## Authentication

- `Authorization` header (bearer token, required) — Paste a Keycloak access token (no "Bearer " prefix)

## Servers

- `https://unsw-v6-dev.advance-uac.com/institution-api` (Dev, default)
- `https://unsw-v6-test.advance-uac.com/institution-api` (Test)

## Request

### Path parameters

- `actionId` (string, required)
- `id` (string, required)

### Body (application/json)

This endpoint expects a ResolveActionRequest.

- `note` (string, optional) — What you sent, in your own words. Optional, and kept against the action for the assessor to read.

## Response

### 200

The action is resolved.

- `id` (string, optional)
- `actionType` (string, optional) — DOCUMENT_REQUIRED, CLARIFICATION, VERIFICATION or OTHER.
- `description` (string, optional) — What is needed, in the assessor's words.
- `state` (string, optional) — OPEN while outstanding; RESOLVED once met; CANCELLED if it turned out not to be needed.
- `qualificationId` (string, optional) — The qualification this is about, when it is about one in particular. Null for an ask that stands on its own.
- `raisedAt` (datetime, optional)
- `resolvedAt` (datetime, optional) — Null while the action is OPEN.
- `resolvedBySource` (string, optional) — Who closed it: `institution_api` if you did, `officer` if the assessment team did. Null while the action is OPEN.

## Errors

### 400 Bad Request Error

Bad Request

- `any`

### 404 Not Found Error

No such resource for this institution.

- `status` (integer, optional) — Repeats the HTTP status code.
- `error` (string, optional) — What went wrong, in a form safe to show a developer.

## Examples

**Request**

```json
{}
```

**Response**

```json
{
  "id": "string",
  "actionType": "DOCUMENT_REQUIRED",
  "description": "Certified transcript for the Diploma of Business",
  "state": "OPEN",
  "qualificationId": "string",
  "raisedAt": "2022-03-10T12:15:50-04:00",
  "resolvedAt": "2022-03-10T12:15:50-04:00",
  "resolvedBySource": "institution_api"
}
```

**SDK Code**

```python
import requests

url = "https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/pending-actions/actionId/resolve"

payload = {}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/pending-actions/actionId/resolve';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/pending-actions/actionId/resolve"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/pending-actions/actionId/resolve")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/pending-actions/actionId/resolve")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/pending-actions/actionId/resolve', [
  'body' => '{}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/pending-actions/actionId/resolve");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/pending-actions/actionId/resolve")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```