> 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/unsw-advance-institution-api/applications/withdraw-an-application/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.

# Withdraw an application

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

Moves the application to WITHDRAWN and closes any assessment that had started, so it stops appearing in an assessor's queue. NOT REVERSIBLE: there is no un-withdraw, and reinstating means sending a new application. 404 if unknown, 409 if already withdrawn or if its assessment workflow has no WITHDRAWN status to move to.

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

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

- `reason` (string, optional) — Why it was withdrawn. Optional.

## Response

### 200

The application is WITHDRAWN.

- `id` (string, optional)
- `applicantId` (string, optional)
- `programCode` (string, optional)
- `year` (integer, optional)
- `stream` (string, optional)
- `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, 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.
- `submittedAt` (datetime, optional)
- `updatedAt` (datetime, optional)

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

### 409 Conflict Error

The application is already withdrawn, or its assessment workflow has no WITHDRAWN status, so withdrawing it would leave the assessment reading as though it were still live.

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

## Examples

**Request**

```json
{}
```

**Response**

```json
{
  "id": "string",
  "applicantId": "string",
  "programCode": "string",
  "year": 1,
  "stream": "string",
  "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"
    }
  ],
  "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/withdraw"

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/withdraw';
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/withdraw"

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

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/withdraw")
  .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/withdraw', [
  '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/withdraw");
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/withdraw")! 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()
```