> 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/submit-a-new-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.

# Submit a new application

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

Creates an application for an applicant (status RECEIVED) and returns their ids.

The applicant is resolved in this order: by `applicant.sourceRef` if you send one, otherwise by
identity (`givenNames`, `familyName`, `dob`, `emailAddress`). An existing applicant is reused;
otherwise a new one is created and stamped with whatever source details you supplied.

The application's own `sourceName` / `sourceRef` are separate from the applicant's. The former
is your application number, the latter your student number. Both optional, both unique within
a `sourceName`, and either one lets you find the record again without storing our UUID.

Any qualifications supplied are added to the application. Assessment is asynchronous, so poll
GET /institution/applications/\{id} for the outcome.

`specialisations` is optional and takes handbook codes; see the field for how they are read.
Leaving it out behaves exactly as before, so an existing integration needs no change.

Reference: https://docs-unsw-v6.advance-uac.com/unsw-advance-institution-api/applications/submit-a-new-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

### Body (application/json)

This endpoint expects a SubmitApplicationRequest.

- `applicant` (ApplicantInput, optional) — The applicant. Matched by identity (givenName1, familyName, dob, emailAddress); reused if they already exist for this institution, otherwise created.
- `programCode` (string, optional) — UNSW program code, e.g. "4825".
- `year` (integer, optional) — Commencement (cohort) year, e.g. 2026.
- `stream` (string, optional) — Admission stream, e.g. "DOMESTIC_FP".
- `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.
- `description` (string, optional) — Optional free-text note.
- `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.
- `qualifications` (list of NewQualification, optional) — Qualifications to add to the applicant. Optional.
- `specialisations` (list of string, optional) — The specialisations this application is for, as handbook codes — the majors, minors, honours streams or research areas the applicant is taking alongside the program. Optional, and an application without any is completely normal: most programs offer none. Two is the usual maximum, and the applicant portal enforces that, but this endpoint does not — what you send is what happened. The codes are resolved against the application's own `year`, the same handbook year `programCode` is read in, so you send codes alone rather than a second code-and-year pair. A code the catalogue does not hold for that year is a 400 naming it.

## Response

### 200

OK

- `id` (string, optional) — Application id, used to poll status or add qualifications and documents.
- `applicantId` (string, optional) — The created applicant's id.
- `status` (string, optional) — Always RECEIVED on submit.

## Errors

### 400 Bad Request Error

Bad Request

- `any`

## Types

### ApplicantInput

Applicant identity. givenName1, familyName, dob (YYYY-MM-DD) and emailAddress are required; phoneNumber and postalAddress optional.

- `givenName1` (string, optional)
- `givenName2` (string, optional)
- `familyName` (string, optional)
- `dob` (date, optional) — Date of birth, ISO format YYYY-MM-DD.
- `emailAddress` (string, optional)
- `phoneNumber` (string, optional)
- `postalAddress` (string, 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 person, e.g. a student 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.

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

### NewQualification

A qualification the applicant holds. `type` is one of tertiary, subject, work_experience. `data` fields are validated against that type's schema.

- `type` (string, optional) — tertiary | subject | work_experience.
- `source` (string, optional) — Reporting source; defaults to "officer".
- `data` (map from string to any, optional) — Type-specific fields, e.g. \{code, name, institution, completedYear}.
- `subjects` (list of NewQualification, optional) — Nested subjects (for a tertiary qualification).

## Examples

**Request**

```json
{}
```

**Response**

```json
{
  "id": "string",
  "applicantId": "string",
  "status": "string"
}
```

**SDK Code**

```python
import requests

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

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

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

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