> 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.

# Set an application's status

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

Moves an application to any status, with an optional reason saying why. The reason is kept on the application AND on its status history, so "why was this put on hold, and when" has an answer later.

The statuses are `RECEIVED`, `READY`, `PROCESSING`, `ON_HOLD`, `FINALISED` and `FAILED`. `WITHDRAWN` is NOT accepted here — use `/withdraw`, which also closes the assessment workflow. Setting the status alone would leave a workflow that still thinks it is live, so it keeps appearing in an assessor's queue.

Setting the status an application already has succeeds and changes nothing, so a retry is safe and leaves one history entry rather than two.

404 if the application is unknown, 409 if it is withdrawn — that is not reversible, and reinstating means a new application.

Reference: https://docs-unsw-v6.advance-uac.com/unsw-advance-institution-api/applications/set-an-applications-status

## 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

- `id` (string, required)

### Body (application/json)

This endpoint expects a StatusRequest.

- `status` (string, required) — RECEIVED, READY, PROCESSING, ON_HOLD, FINALISED or FAILED. Case is forgiven.
- `reason` (string, optional) — Why, in your own words. Kept on the application and on its status history. Optional, but an ON_HOLD with no reason is hard to act on later.

## Response

### 200

The application, at its new status.

- `id` (string, optional)
- `applicantId` (string, optional)
- `programCode` (string, optional)
- `year` (integer, optional)
- `stream` (string, optional)
- `applicationType` (string, optional) — Whether this is a domestic or an international application: `DOMESTIC` or `INTERNATIONAL`. Optional, and case is forgiven. On the APPLICATION, not the person. The same applicant can be domestic for one application and international for another, so an application records what was true when it was lodged. Distinct from `stream`, which is your own admission stream and says more than this. Send both: we cannot read your stream codes, and this is the field our officers and rules can act on.
- `intakeCode` (string, optional) — Your own code for the intake the applicant is starting, e.g. "5269" for Term 3 2026. Optional, but worth sending: our officers work applications in intake order, and one with no intake cannot be prioritised against the rest. Send the code rather than the name. These are YOUR term codes, loaded from the intake schedule you supply us, so a code you use is a code we hold; one we do not recognise is refused with a 400 naming it.
- `intake` (string, optional) — The intake's name, e.g. "Term 3 2026". Null when no intake is set.
- `status` (string, optional) — Application status: RECEIVED, READY, PROCESSING, ON_HOLD, FINALISED, WITHDRAWN or FAILED.
- `statusDetail` (string, optional) — Failure detail when status is FAILED; null otherwise.
- `workflowStatus` (string, optional) — Assessment workflow status once processed (e.g. DECIDED, CREDIT_TEAM_REVIEW); null while RECEIVED.
- `qualifications` (list of QualificationView, optional)
- `sourceName` (string, optional) — The system this record was fed from, in your own vocabulary. Free text, and required whenever you send a sourceRef.
- `sourceRef` (string, optional) — Your own unique id for this application, e.g. an application number. Unique per `sourceName`.
- `sources` (list of ApplicationSourceReference, optional) — Your own references for this record, one per system you keep it in. A person or an application known by a different id in SITS than elsewhere carries both. Optional. `sourceName` and `sourceRef` still work exactly as before and count as the FIRST entry here, so nothing you have already built needs to change. Send both forms and they are combined, with duplicates collapsed. Order matters: the first entry is the one echoed back as `sourceRef`, and the one shown in lists and in the change feed.
- `specialisations` (list of ApplicationSpecialisation, optional) — The specialisations this application is for, in the order they were chosen. Empty when there are none.
- `pendingActions` (list of PendingAction, optional) — What this application is waiting on, oldest first. Each entry is one thing we need before the assessment can go further. Empty when nothing is outstanding — which is the normal case, not a problem.
- `submittedAt` (datetime, optional)
- `updatedAt` (datetime, optional)

## Errors

### 400 Bad Request Error

No status was sent, the status is not one of the six, or `WITHDRAWN` was sent — use the withdraw endpoint for that.

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

### 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.

### 409 Conflict Error

The application is withdrawn.

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

## Types

### QualificationView

A qualification as stored.

- `id` (string, optional)
- `type` (string, optional) — tertiary | subject | work_experience.
- `parentId` (string, optional) — The qualification this one sits under — a subject's degree. Null for a top-level qualification.
- `data` (map from string to any, optional) — The type-specific fields, consolidated across every source that has reported this qualification.
- `documentCount` (integer, optional) — How many supporting documents are attached, so you can tell at a glance whether evidence has been uploaded. Counts confirmed uploads only; list them with GET /institution/qualifications/\{id}/documents.

### ApplicationSourceReference

One of your own references for this record: the system it came from, and its id there.

- `sourceName` (string, optional) — The system this record was fed from, in your own vocabulary. Free text, and required whenever you send a sourceRef.
- `sourceRef` (string, optional) — Your own unique id for this application, e.g. an application number. Unique per `sourceName`.

### ApplicationSpecialisation

One specialisation an application is for. `code` and `year` are what the application recorded; `name` and `type` are the catalogue's own words and are null if the catalogue no longer holds that specialisation.

- `code` (string, optional)
- `year` (integer, optional) — Handbook year, the application's own year.
- `name` (string, optional)
- `type` (string, optional) — Major, Minor, Honours, Specialisation or Research.

### PendingAction

One thing an application is waiting on. Raised by an assessor; resolved by whichever side gets there first — POST .../pending-actions/\{actionId}/resolve once you have supplied it, or an assessor closes it themselves.

- `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.

## Examples

**Request**

```json
{
  "status": "ON_HOLD"
}
```

**Response**

```json
{
  "id": "string",
  "applicantId": "string",
  "programCode": "string",
  "year": 1,
  "stream": "string",
  "applicationType": "DOMESTIC",
  "intakeCode": "5269",
  "intake": "string",
  "status": "string",
  "statusDetail": "string",
  "workflowStatus": "string",
  "qualifications": [
    {
      "id": "string",
      "type": "string",
      "parentId": "string",
      "data": {},
      "documentCount": 1
    }
  ],
  "sourceName": "SITS",
  "sourceRef": "APP-2026-00123",
  "sources": [
    {
      "sourceName": "SITS",
      "sourceRef": "APP-2026-00123"
    }
  ],
  "specialisations": [
    {
      "code": "SOCAE1",
      "year": 2026,
      "name": "Sociology",
      "type": "Major"
    }
  ],
  "pendingActions": [
    {
      "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"
    }
  ],
  "submittedAt": "2022-03-10T12:15:50-04:00",
  "updatedAt": "2022-03-10T12:15:50-04:00"
}
```

**SDK Code**

```python
import requests

url = "https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/status"

payload = { "status": "ON_HOLD" }
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/status';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"status":"ON_HOLD"}'
};

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/status"

	payload := strings.NewReader("{\n  \"status\": \"ON_HOLD\"\n}")

	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/status")

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 = "{\n  \"status\": \"ON_HOLD\"\n}"

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/status")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"status\": \"ON_HOLD\"\n}")
  .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/status', [
  'body' => '{
  "status": "ON_HOLD"
}',
  '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/status");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"status\": \"ON_HOLD\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["status": "ON_HOLD"] 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/status")! 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()
```