# Australia Visa Processing Time Monitor (`nerolabs/au-visa-processing-monitor`) Actor

Look up and monitor Australia's official published visa processing times (25th/50th/75th/90th percentile days) per visa subclass and stream, with a recurring monitor mode that flags whenever the Department of Home Affairs updates its own figures.

- **URL**: https://apify.com/nerolabs/au-visa-processing-monitor.md
- **Developed by:** [Adam Pearce](https://apify.com/nerolabs) (community)
- **Categories:** Travel, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 visa processing-time lookups

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### What does Australia Visa Processing Time Monitor do?

Tracking a client through the Australian visa system and can't tell them how much longer to expect? This Actor looks up **Australia's own official, published visa processing times** (25th, 50th, 75th, and 90th percentile days to a decision) for any visa subclass and stream, straight from the Department of Home Affairs' Global Visa Processing Times data. Point it at one subclass for a quick check, a list for bulk checks across a whole caseload, turn on Monitor mode to get flagged only when Home Affairs actually updates its figures, or feed in your own client list with application dates to get a plain-English read on roughly where each one stands.

Data comes straight from the same JSON API that powers Home Affairs' own [Global Visa Processing Times](https://immi.homeaffairs.gov.au/visas/getting-a-visa/visa-processing-times/global-visa-processing-times) page, no scraping, no HTML parsing, no anti-bot fight. Run it via the Apify Console, the API, or on a schedule, and export results as JSON, CSV, or Excel.

### Why use this Actor?

- **Migration agents** tracking dozens of visa subclasses across a growing client base, who need to answer "how long will mine take?" without manually re-checking a government page for every subclass, every client, every week. Client tracking mode turns your own caseload into a quick-glance table: who's early, who's around the typical wait, and who's past the point where an inquiry might be worth making.
- **Immigration lawyers and consultancies** who want a standing alert the moment a subclass they've quoted a client on moves faster or slower than expected.
- **Applicants and sponsoring employers** who want to watch their own subclass's processing time without refreshing a government page by hand.
- **HR and mobility teams** at companies sponsoring overseas hires, tracking Employer Nomination Scheme and skilled visa timelines across multiple candidates at once.

### How to use Australia Visa Processing Time Monitor

1. Click **Try for free** or **Run** on the Actor page.
2. Don't know the exact subclass/stream codes? Turn on `listAvailableVisas` and run once, free, to get the full current reference list (100+ pairs).
3. Enter a single `visaSubclassCode` (and `streamCode` if that subclass has one) for a quick lookup, or a list of `targets` for bulk checks.
4. To track subclasses over time, turn on `monitorMode`, keep the same `targets` and `watchlistId`, and schedule the Actor weekly or monthly (Home Affairs republishes roughly monthly, so daily adds no signal). Each run only charges for what actually changed.
5. Tracking a whole caseload? Fill in `clients`, one row per client with their subclass, stream, and application date. You'll get the current percentiles plus a plain-English estimate of where each one likely stands and an expected decision window, worked out purely from the published statistics (see the FAQ on what this is and isn't).
6. View results in the Console table, or pull them via the API/dataset export.

### Input

See the Input tab for the full schema. Key fields:

| Field                 | Description                                                                                          |
| --------------------- | ------------------------------------------------------------------------------------------------------ |
| `visaSubclassCode`    | A single subclass code to look up, e.g. `186`.                                                       |
| `streamCode`          | That subclass's stream, if it has one, e.g. `3`. Leave blank for subclasses with no stream.          |
| `targets`             | A list for bulk lookup or Monitor mode, one per line, as `subclassCode` or `subclassCode:streamCode`. |
| `monitorMode`         | When true, compares against the last run and only reports what changed.                              |
| `watchlistId`         | Keeps separate Monitor mode histories if you run more than one watchlist.                             |
| `listAvailableVisas`  | Free reference lookup: returns every valid subclass/stream pair Home Affairs currently publishes.    |
| `clients`             | Your own caseload: an array of `{clientLabel, visaSubclassCode, streamCode, applicationDate}` rows. Ignores every other input when used. |

### Output

Each result includes the visa's identity and its full percentile spread. Example (a single record):

```json
{
    "visaSubclassCode": "186",
    "streamCode": "3",
    "visaSubclassText": "Employer Nomination Scheme (subclass 186)",
    "streamText": "Direct Entry Pathway",
    "found": true,
    "percentile25Days": 192,
    "percentile50Days": 301,
    "percentile75Days": 358,
    "percentile90Days": 437,
    "percentile25Text": "6 Months",
    "percentile50Text": "10 Months",
    "percentile75Text": "12 Months",
    "percentile90Text": "14 Months",
    "maxDays": 544,
    "sourceUrl": "https://immi.homeaffairs.gov.au/visas/getting-a-visa/visa-listing/employer-nomination-scheme-186/direct-entry-stream",
    "dataRetrievedAt": "2026-08-14T13:08:12.436Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

Client tracking mode adds a plain-English estimate on top (a single record, trimmed):

```json
{
    "clientLabel": "Smith, J.",
    "visaSubclassCode": "186",
    "streamCode": "3",
    "applicationDate": "2026-03-01",
    "daysSinceApplication": 168,
    "estimatedProgressPercent": 56,
    "progressStage": "Early days, well within the fastest 25% of current cases.",
    "expectedDecisionEarliest": "2026-09-09",
    "expectedDecisionTypical": "2026-12-27",
    "expectedDecisionLatest": "2027-05-12",
    "estimateDisclaimer": "Statistical estimate only, calculated from the published percentile figures and the application date you gave us. This is not a real-time case status..."
}
```

### Data table

| Field                                                          | What it is                                                                                          |
| ---------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| `visaSubclassText`, `streamText`                                | The visa's full name and stream, as Home Affairs labels it.                                        |
| `found`, `notFoundReason`                                       | Whether a published figure exists for this pair, and why not if it doesn't.                        |
| `percentile25Days` … `percentile90Days`                        | Days-to-decision at the 25th, 50th, 75th, and 90th percentile of applications processed.            |
| `percentile25Text` … `percentile90Text`                        | The same figures in Home Affairs' own human-readable form (e.g. "10 Months").                       |
| `maxDays`                                                       | The longest processing time Home Affairs quotes for this pair.                                      |
| `processGuideNote`                                               | Any current note Home Affairs has attached (e.g. a backlog warning), where present.                 |
| `sourceUrl`                                                      | Direct link to this visa's own page on immi.homeaffairs.gov.au.                                     |
| `changeDetected`, `changeSummary`                                | Monitor mode only: whether anything moved since the last check, and what.                           |
| `daysSinceApplication`                                           | Client tracking only: days between the application date you gave and today.                          |
| `estimatedProgressPercent`, `progressStage`                      | Client tracking only: a statistical read on where the application likely stands, see the FAQ.        |
| `expectedDecisionEarliest`, `expectedDecisionTypical`, `expectedDecisionLatest` | Client tracking only: application date plus the 25th/50th/90th percentile days.         |

### Pricing / Cost estimation

Pay-per-event pricing, no subscription. A single lookup or bulk check costs $0.01 per subclass/stream checked, including a pair with no published figure, a confirmed "not found" is still a real, useful result telling you the code is wrong or unpublished. The `listAvailableVisas` reference lookup is always free. Watching 20 subclasses monthly in Monitor mode (matching how often Home Affairs actually updates these figures) costs roughly $0.04 to $1/month depending on how many actually move that month ($0.002 per no-change confirmation, $0.05 per real change caught). Client tracking costs $0.015 per client row checked, including a row with an invalid date or a not-found subclass, still a real, useful result.

### Tips

- Run once with `listAvailableVisas` on to get the exact current codes before setting up a bulk lookup or a watchlist, subclass/stream pairs occasionally change.
- Bulk lookups (`targets`) are faster than repeated single-subclass runs, they're all fetched in one Actor run.
- For ongoing monitoring, schedule the Actor (Apify's built-in Schedules) monthly rather than daily, Home Affairs republishes these figures roughly monthly, so a tighter schedule mostly just pays for extra no-change confirmations.
- Keep `watchlistId` consistent across scheduled runs for the same list, changing it starts a fresh watch history.

### FAQ

**Is this legal? Doesn't this need a login or bypass a CAPTCHA?**
No login, no CAPTCHA. This Actor calls the same plain JSON endpoint Home Affairs' own public Global Visa Processing Times page uses to populate itself. Home Affairs' content defaults to a Creative Commons Attribution 3.0 Australia licence, with no resale or scraping prohibition found.

**Does this track my own personal visa application?**
No, and this is deliberate. Home Affairs' personal case-status tools require your own logged-in portal access, this Actor only reports the *aggregate, published* processing-time figures per visa subclass, the same numbers everyone applying for that subclass can already see on the government's own page, just structured and monitorable.

**What does "not found" mean here?**
Either the subclass/stream code is wrong, or Home Affairs currently publishes no figure for that pair at all (not every subclass appears on the Global Visa Processing Times page). Run with `listAvailableVisas` on to confirm the exact valid codes.

**How current is the data?**
Home Affairs updates these figures roughly monthly. This Actor always reads the live current figures, it never caches or bundles data of its own.

**Is the client-tracking "progress %" and "expected decision" a real case status?**
No, and this matters: read it carefully before relying on it. Home Affairs doesn't publish a real-time status for any individual application on any endpoint we could find (see "Does this track my own personal visa application?" above), so nothing can tell you the actual state of a specific client's file. What client tracking mode gives you is a **statistical estimate**: it takes the days since the application date you provided and compares it against the published population percentiles for that subclass. "56% progress" means "168 of a typical 301-day wait have passed," not "this file is 56% processed." Treat it as a rough, honest read on whether a client is running early, typical, or later than most, useful for deciding who to check on, not a confirmed fact about any one file.

If this Actor saved you a manual check, a review on the Actor page helps a lot and helps decide what to build next. Found a bug or have a request, including support for another country's processing-time data? Use the Issues tab, replies are personal, not automated.

***

*Data sourced from the Australian Government Department of Home Affairs' Global Visa Processing Times, licensed under Creative Commons Attribution 3.0 Australia. This Actor is not affiliated with or endorsed by the Department of Home Affairs.*

# Actor input Schema

## `visaSubclassCode` (type: `string`):

The numeric subclass code, e.g. 186 for the Employer Nomination Scheme visa. Use this for a single-record lookup. Don't know the code? Run once with 'List all available visas' turned on instead.

## `streamCode` (type: `string`):

Some subclasses have multiple streams, each with its own processing time (e.g. subclass 186 has stream 3, 'Direct Entry Pathway'). Leave blank for subclasses that have no stream. Only used alongside 'Visa subclass code' above.

## `targets` (type: `array`):

A list of subclass/stream pairs to check, one per line, as 'subclassCode' (no stream) or 'subclassCode:streamCode'. Examples: '189' (Skilled Independent, no stream) or '186:3' (Employer Nomination Scheme, Direct Entry Pathway). Required for Monitor mode (that's what gives each pair a stable identity to track over time). Also the fastest way to check many subclasses in one run. Don't know the exact codes? Run once with 'List all available visas' turned on to get the full reference list first.

## `monitorMode` (type: `boolean`):

When true, the Actor remembers each subclass/stream's last-seen 25th/50th/75th/90th percentile processing times and reports only what changed since the last check, or a cheap no-change confirmation. Schedule this Actor to run weekly or monthly with the same targets and watchlistId (Home Affairs updates these figures roughly monthly). Requires visaSubclassCode and/or targets.

## `watchlistId` (type: `string`):

Only needed if you're running more than one independent monitored watchlist from the same Apify account (e.g. one per client) and want their change history kept separate. Leave as default otherwise.

## `listAvailableVisas` (type: `boolean`):

When true, ignores every other input and instead returns the full current list of every visa subclass/stream pair the Department of Home Affairs publishes processing times for (100+), so you can find the exact codes to use above. This reference lookup is never charged.

## `clients` (type: `array`):

Track your own caseload: one row per client with their visa subclass/stream and application date. Ignores every other input when used. Returns the current percentile figures plus an honest statistical estimate of roughly where each application should stand (NOT a real case status, Home Affairs doesn't publish one, see the README FAQ). Each row: {"clientLabel": "your own reference, e.g. a name or file number", "visaSubclassCode": "186", "streamCode": "3" (optional), "applicationDate": "2026-03-01"}.

## Actor input object example

```json
{
  "visaSubclassCode": "186",
  "streamCode": "3",
  "targets": [],
  "monitorMode": false,
  "watchlistId": "default",
  "listAvailableVisas": false,
  "clients": []
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "visaSubclassCode": "186",
    "streamCode": "3"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nerolabs/au-visa-processing-monitor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "visaSubclassCode": "186",
    "streamCode": "3",
}

# Run the Actor and wait for it to finish
run = client.actor("nerolabs/au-visa-processing-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "visaSubclassCode": "186",
  "streamCode": "3"
}' |
apify call nerolabs/au-visa-processing-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nerolabs/au-visa-processing-monitor"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0u8XGmTHhaia4fmrg/builds/lSqxUYcSAlxTJ5UZG/openapi.json