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

# Get an application's credit decision

GET https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/{id}/outcome

The credit decision on an application: what was awarded, what it counts towards, and what it
is finally worth.

**Read `assessed` first.** False means no assessment has run, so `credits` is empty because
nothing has been considered — not because nothing was awarded. An application submitted
through this API stays that way until it is picked up for assessment.

**Then read `finalOutcome`.** While it is false the workflow is still running and the credit
below can still change. True means the workflow has reached an end state and this is the
answer.

**`uoc` is always what the credit is worth now.** An officer can reject a grant, re-price it,
or mark it exempt. A rejected or exempt grant stays in the list, with its reason, counting 0
— you can see everything that was considered, and `totalCreditUoc` is a plain sum of the
column. Where an officer changed the number, `assessedUoc` carries what the pipeline had
originally said; where they did not, it is absent.

`credits` also includes anything an officer awarded outright, marked `origin: manual`. Those
have no `reason`, because no rule produced them.

404 if the application id is unknown or belongs to another institution.

Reference: https://docs-unsw-v6.advance-uac.com/unsw-advance-institution-api/applications/get-an-applications-credit-decision

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

## Response

### 200

The credit decision as it currently stands.

- `applicationId` (string, optional)
- `status` (string, optional) — Intake status: RECEIVED, READY, PROCESSING, WITHDRAWN or FAILED.
- `statusDetail` (string, optional) — Why intake failed, when status is FAILED. Null otherwise.
- `workflowStatus` (string, optional) — Assessment workflow status code; null until the application is assessed.
- `workflowStatusLabel` (string, optional) — That status in words, e.g. "Decided".
- `assessed` (boolean, optional) — Whether an assessment has run at all. False means no credit has been considered yet, not that none was awarded.
- `finalOutcome` (boolean, optional) — Whether the workflow has reached an end state. While false the credit below is provisional and can still change.
- `assessedAt` (datetime, optional) — When assessment started; null until it does.
- `completedAt` (datetime, optional) — When the workflow reached its end state; null while it is still running.
- `totalCreditUoc` (integer, optional) — Total credit awarded, in units of credit. The sum of `uoc` below, so rejected credit contributes nothing.
- `awaitingAuthority` (boolean, optional) — Whether any credit below is waiting on an academic authority. That credit IS counted in `totalCreditUoc` — it stands unless the authority refuses it — so while this is true the total can still fall. `finalOutcome` is false whenever it is true. Read `authorityState` on each credit to see which ones.
- `credits` (list of Credit, optional) — Every piece of credit considered, including any rejected.

## Errors

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

## Types

### Credit

One piece of credit: what earned it, what it counts towards, and what it is worth.

- `id` (string, optional) — This one piece of credit. Unique within the assessment.
- `decisionId` (string, optional) — The DECISION this credit belongs to. Several credits share it when one decision awarded several units — a mapping with three targets produces three credits with one `decisionId`. Group on it to show what was decided together.
- `origin` (string, optional) — `assessed` — produced by the assessment pipeline. `manual` — awarded by an officer outright.
- `status` (string, optional) — `granted` — it counts. `rejected` — an officer struck it out; it stays on the record with its reason and counts 0. `exempt` — the requirement is met without credit, also 0.
- `provisional` (boolean, optional) — The credit is approved and counted, but the applicant does not receive it until they have completed the further study described in `note` — typically after a year. `status` stays `granted` because that is what it is; this says when it lands. It does not affect `totalCreditUoc` or `finalOutcome`.
- `uoc` (integer, optional) — Units of credit awarded, after any officer override. 0 when rejected or exempt.
- `assessedUoc` (integer, optional) — What the pipeline assessed, present ONLY when an officer changed it. Its presence is how you tell an override from a plain grant.
- `authorityState` (string, optional) — Where this credit stands with an academic authority, when the credit team escalated it to one. `awaiting` — sent and not answered; it counts towards the total and could still be refused. `confirmed` — the authority agreed; it stands. `refused` — the authority rejected it; `uoc` is 0 and `assessedUoc` says what it would have been. NULL is the normal case: nobody was asked, because auto-matched credit is approved and the credit team decides it.
- `mechanism` (string, optional) — How it was earned: articulation, precedent, rpl, employment, or manual.
- `category` (string, optional) — For block credit, what kind: core, elective or employment. Null for credit against a named unit.
- `targetUnitCode` (string, optional) — The unit the credit counts towards. Null for block credit, which is granted against a category rather than a named unit.
- `sources` (list of CreditSource, optional) — The prior study or experience that earned it.
- `reason` (string, optional) — Why the pipeline awarded it, in its own words.
- `note` (string, optional) — The officer's note, when they recorded one.
- `decidedAt` (datetime, optional) — When it was decided — the officer's decision if there was one, otherwise when the pipeline awarded it.

### CreditSource

Prior study or experience that earned credit.

- `type` (string, optional) — What kind of thing it is: `subject` or `course` for a unit of study, `tertiary` for a whole qualification, `work_experience` for a job.
- `code` (string, optional) — Its code, as supplied.
- `name` (string, optional) — Its name, where one was recorded. Present when the credit came from a mapping, which stores names alongside codes; absent on the rules-based paths, which carry codes only.

## Examples

### Not yet assessed

**Response**

```json
{
  "applicationId": "9c1f4d3e-6b2a-4f18-9c77-2b5a1e0d8f42",
  "status": "RECEIVED",
  "assessed": false,
  "finalOutcome": false,
  "totalCreditUoc": 0,
  "credits": []
}
```

**SDK Code**

```python Not yet assessed
import requests

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

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Not yet assessed
const url = 'https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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

```go Not yet assessed
package main

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

func main() {

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

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

```ruby Not yet assessed
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

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

```java Not yet assessed
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Not yet assessed
using RestSharp;

var client = new RestClient("https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Not yet assessed
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()
```

### Assessed, still under review

**Response**

```json
{
  "applicationId": "9c1f4d3e-6b2a-4f18-9c77-2b5a1e0d8f42",
  "status": "PROCESSING",
  "workflowStatus": "CREDIT_TEAM_REVIEW",
  "workflowStatusLabel": "Credit team review",
  "assessed": true,
  "finalOutcome": false,
  "assessedAt": "2026-08-24T09:15:02.113+10:00",
  "totalCreditUoc": 12,
  "credits": [
    {
      "id": "0b6e5c21-9a44-4f0e-93b1-77c2d5a10e64",
      "decisionId": "7c2e91a4-5f38-4d16-a0b9-1e8d3f5c7a20",
      "origin": "assessed",
      "status": "granted",
      "uoc": 6,
      "mechanism": "precedent",
      "targetUnitCode": "COMM6106",
      "sources": [
        {
          "type": "course",
          "code": "30012",
          "name": "Mathematics"
        },
        {
          "type": "course",
          "code": "30177",
          "name": "Statistics"
        },
        {
          "type": "course",
          "code": "30221",
          "name": "Principles of Management"
        },
        {
          "type": "course",
          "code": "30498",
          "name": "Econometrics"
        }
      ],
      "reason": "Precedent: 30498 + 30012 + 30221 + 30177 → COMM6106",
      "decidedAt": "2026-08-24T09:15:04.882+10:00"
    },
    {
      "id": "3d9a7e08-1c65-4b2f-8a30-6e4f9b7c2d15",
      "decisionId": "7c2e91a4-5f38-4d16-a0b9-1e8d3f5c7a20",
      "origin": "assessed",
      "status": "granted",
      "uoc": 6,
      "mechanism": "precedent",
      "targetUnitCode": "COMM6112",
      "sources": [
        {
          "type": "course",
          "code": "30012",
          "name": "Mathematics"
        },
        {
          "type": "course",
          "code": "30177",
          "name": "Statistics"
        },
        {
          "type": "course",
          "code": "30221",
          "name": "Principles of Management"
        },
        {
          "type": "course",
          "code": "30498",
          "name": "Econometrics"
        }
      ],
      "reason": "Precedent: 30498 + 30012 + 30221 + 30177 → COMM6112",
      "decidedAt": "2026-08-24T09:15:04.884+10:00"
    }
  ]
}
```

**SDK Code**

```python Assessed, still under review
import requests

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

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Assessed, still under review
const url = 'https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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

```go Assessed, still under review
package main

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

func main() {

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

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

```ruby Assessed, still under review
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

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

```java Assessed, still under review
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Assessed, still under review
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Assessed, still under review
using RestSharp;

var client = new RestClient("https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Assessed, still under review
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()
```

### Decided

**Response**

```json
{
  "applicationId": "9c1f4d3e-6b2a-4f18-9c77-2b5a1e0d8f42",
  "status": "PROCESSING",
  "workflowStatus": "DECIDED",
  "workflowStatusLabel": "Decided",
  "assessed": true,
  "finalOutcome": true,
  "assessedAt": "2026-08-24T09:15:02.113+10:00",
  "completedAt": "2026-08-25T14:02:47.500+10:00",
  "totalCreditUoc": 18,
  "credits": [
    {
      "id": "0b6e5c21-9a44-4f0e-93b1-77c2d5a10e64",
      "decisionId": "0b6e5c21-9a44-4f0e-93b1-77c2d5a10e64",
      "origin": "assessed",
      "status": "granted",
      "uoc": 6,
      "mechanism": "precedent",
      "targetUnitCode": "COMP1511",
      "sources": [
        {
          "type": "subject",
          "code": "31251"
        }
      ],
      "reason": "Matched credit mapping 4f2b (exchange)",
      "decidedAt": "2026-08-24T09:15:04.882+10:00"
    },
    {
      "id": "3d9a7e08-1c65-4b2f-8a30-6e4f9b7c2d15",
      "decisionId": "3d9a7e08-1c65-4b2f-8a30-6e4f9b7c2d15",
      "origin": "assessed",
      "status": "rejected",
      "uoc": 0,
      "assessedUoc": 6,
      "mechanism": "rpl",
      "category": "elective",
      "sources": [
        {
          "type": "subject",
          "code": "31241"
        }
      ],
      "reason": "Cognate elective credit at introductory level",
      "note": "Content overlaps the precedent credit already granted for COMP1511.",
      "decidedAt": "2026-08-25T13:41:11.204+10:00"
    },
    {
      "id": "8a2c6f14-4d70-4e93-b512-0f8e3a9d7c26",
      "decisionId": "8a2c6f14-4d70-4e93-b512-0f8e3a9d7c26",
      "origin": "assessed",
      "status": "exempt",
      "uoc": 0,
      "assessedUoc": 6,
      "mechanism": "rpl",
      "category": "core",
      "targetUnitCode": "MATH1131",
      "sources": [
        {
          "type": "subject",
          "code": "33130"
        }
      ],
      "reason": "Equivalent to MATH1131",
      "note": "Prerequisite satisfied; no credit points awarded.",
      "decidedAt": "2026-08-25T13:44:02.881+10:00"
    },
    {
      "id": "c47b1f90-2e58-4a6d-9138-5b0c7e2a4f83",
      "decisionId": "c47b1f90-2e58-4a6d-9138-5b0c7e2a4f83",
      "origin": "manual",
      "status": "granted",
      "uoc": 12,
      "mechanism": "manual",
      "category": "elective",
      "sources": [
        {
          "type": "work_experience",
          "code": "261313",
          "name": "Software Engineer, Atlassian"
        }
      ],
      "note": "Four years in role; block elective credit approved by the credit team.",
      "decidedAt": "2026-08-25T13:58:30.019+10:00"
    }
  ]
}
```

**SDK Code**

```python Decided
import requests

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

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Decided
const url = 'https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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

```go Decided
package main

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

func main() {

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

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

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

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

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

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

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

HttpResponse<String> response = Unirest.get("https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Decided
using RestSharp;

var client = new RestClient("https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Decided
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()
```

### Decided, no credit

**Response**

```json
{
  "applicationId": "9c1f4d3e-6b2a-4f18-9c77-2b5a1e0d8f42",
  "status": "PROCESSING",
  "workflowStatus": "DECIDED",
  "workflowStatusLabel": "Decided",
  "assessed": true,
  "finalOutcome": true,
  "assessedAt": "2026-08-24T09:15:02.113+10:00",
  "completedAt": "2026-08-24T09:15:06.240+10:00",
  "totalCreditUoc": 0,
  "credits": []
}
```

**SDK Code**

```python Decided, no credit
import requests

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

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Decided, no credit
const url = 'https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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

```go Decided, no credit
package main

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

func main() {

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

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

```ruby Decided, no credit
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

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

```java Decided, no credit
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Decided, no credit
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Decided, no credit
using RestSharp;

var client = new RestClient("https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Decided, no credit
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()
```

### Intake failed

**Response**

```json
{
  "applicationId": "9c1f4d3e-6b2a-4f18-9c77-2b5a1e0d8f42",
  "status": "FAILED",
  "statusDetail": "No workflow configured for program 3778 (2026, DOMESTIC_FP)",
  "assessed": false,
  "finalOutcome": false,
  "totalCreditUoc": 0,
  "credits": []
}
```

**SDK Code**

```python Intake failed
import requests

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

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Intake failed
const url = 'https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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

```go Intake failed
package main

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

func main() {

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

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

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

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

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

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

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

HttpResponse<String> response = Unirest.get("https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Intake failed
using RestSharp;

var client = new RestClient("https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Intake failed
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://unsw-v6-dev.advance-uac.com/institution-api/institution/applications/id/outcome")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()
```