# New Zealand Visa Processing Time Monitor (`nerolabs/nz-visa-processing-monitor`) Actor Look up and monitor Immigration New Zealand's official published visa processing times (50th/80th percentile working days) per visa type, with a recurring monitor mode that flags whenever Immigration NZ updates its own figures. - **URL**: https://apify.com/nerolabs/nz-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 New Zealand Visa Processing Time Monitor do? Tracking a client through New Zealand's immigration system and can't tell them how much longer to expect? This Actor looks up **Immigration New Zealand's own official, published visa processing times** (50th and 80th percentile working days to a decision) for any of the 130+ visa types INZ publishes a figure for, straight from its own "Check visa application processing times" tool. Look up one visa by name for a quick check, a list for bulk checks across a whole caseload, turn on Monitor mode to get flagged only when INZ actually updates its figures, or feed in your own client list with application dates to get the same estimated decision window INZ's own tool would show for that date. Data comes straight from the same JSON API that powers Immigration New Zealand's own [processing time checker](https://www.immigration.govt.nz/process-to-apply/waiting-for-a-visa/processing-a-visa-application/how-long-it-takes-to-process-an-application/check-visa-application-processing-time/), 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 clients across dozens of visa categories, who need to answer "how long will mine take?" without manually re-checking a government tool for every visa, every client, every month. Client tracking mode turns your own caseload into a quick-glance table, each row showing the estimated decision window for that client's actual application date. - **Immigration lawyers and consultancies** who want a standing alert the moment a visa type they've quoted a client on gets faster or slower. - **Applicants and sponsors** who want to watch their own visa type's processing time without repeatedly using the government tool by hand. - **HR and mobility teams** at companies sponsoring overseas hires into New Zealand, tracking Accredited Employer Work Visa and residence timelines across multiple candidates at once. ### How to use New Zealand Visa Processing Time Monitor 1. Click **Try for free** or **Run** on the Actor page. 2. Don't know the exact visa name? Turn on `listAvailableVisas` and run once, free, to get the full current reference list (130+ visas with their exact name and numeric ID). 3. Enter a `visaName` (matched case-insensitively, exact match first, then a unique substring) or a numeric `visaId` for a quick lookup, or a list of `targets` for bulk checks (each either a name or an ID). 4. To track visas over time, turn on `monitorMode`, keep the same `targets` and `watchlistId`, and schedule the Actor monthly (INZ republishes these figures roughly monthly, so daily adds no signal). Each run only charges for what actually changed. For long-term monitoring, prefer numeric `visaId`s in `targets` over names, IDs are stable, names occasionally get relabelled. 5. Tracking a whole caseload? Fill in `clients`, one row per client with their visa and application date. You'll get the current percentiles plus the same estimated decision-date window INZ's own tool computes for that date (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 | | -------------------- | ----------------------------------------------------------------------------------------------------------------- | | `visaName` | A single visa's name to look up, e.g. `Skilled Migrant Category Resident Visa`. Matched case-insensitively. | | `visaId` | A single visa's numeric ID, if you already know it. Skips name-matching entirely, takes priority over `visaName`. | | `targets` | A list for bulk lookup or Monitor mode, one per line, each a visa name or numeric ID. | | `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 visa (name + ID) Immigration NZ currently publishes a processing time for. | | `clients` | Your own caseload: an array of `{clientLabel, visaName or visaId, 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 { "rawTarget": "Skilled Migrant Category Resident Visa", "visaId": 61, "visaName": "Skilled Migrant Category Resident Visa", "matchType": "exact", "found": true, "summary": "You can submit an expression of interest if you have a job or job offer from an accredited employer, and qualify for 6 points for your skills and work in New Zealand.", "percentile50Days": 70, "percentile80Days": 108, "averageWait": "10 weeks", "mostWaitTime": "4 months", "sourceUrl": "https://www.immigration.govt.nz/process-to-apply/waiting-for-a-visa/processing-a-visa-application/how-long-it-takes-to-process-an-application/check-visa-application-processing-time/", "dataRetrievedAt": "2026-08-15T16:43:19.088Z" } ``` You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. Client tracking mode adds the estimated decision window on top (a single record, trimmed): ```json { "clientLabel": "Smith, J.", "visaId": 61, "visaName": "Skilled Migrant Category Resident Visa", "applicationDate": "2026-06-01", "percentile50Days": 70, "percentile80Days": 108, "expectedDecisionTypical": "2026-09-07", "expectedDecisionSlower": "2026-10-29", "estimateDisclaimer": "Estimated decision window, calculated the same way Immigration NZ's own tool does..." } ``` ### Data table | Field | What it is | | -------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | | `visaId`, `visaName` | The visa's numeric ID and full name, as Immigration NZ labels it. | | `matchType` | How your input resolved: `id`, `exact` name match, `substring` match, `ambiguous`, or `none`. | | `found`, `notFoundReason` | Whether a published figure exists for this visa, and why not if it doesn't. | | `summary` | Immigration NZ's own plain-English description of who this visa is for. | | `percentile50Days`, `percentile80Days` | Working days to a decision at the 50th and 80th percentile of applications processed. | | `averageWait`, `mostWaitTime` | The same figures in Immigration NZ's own human-readable form (e.g. "10 weeks", "4 months"). | | `sourceUrl` | Link to Immigration NZ's processing time checker tool. | | `changeDetected`, `changeSummary` | Monitor mode only: whether anything moved since the last check, and what. | | `expectedDecisionTypical`, `expectedDecisionSlower` | Client tracking only: application date plus the 50th/80th percentile working days. | | `estimateDisclaimer` | Client tracking only: the estimate methodology and its real limitations, always included, never silent. | ### Pricing / Cost estimation Pay-per-event pricing, no subscription. A single lookup or bulk check costs $0.01 per visa checked, including a visa with no published figure or a name that didn't match, a confirmed "not found" is still a real, useful result telling you the name or ID is wrong or unpublished. The `listAvailableVisas` reference lookup is always free. Watching 20 visas monthly in Monitor mode (matching how often Immigration NZ 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 visa, still a real, useful result. ### Tips - Run once with `listAvailableVisas` on to get the exact current names and IDs before setting up a bulk lookup or a watchlist. - A visa name only needs to be a unique substring, e.g. `"Skilled Migrant"` resolves the same as the full name, as long as it's not ambiguous. An ambiguous or unmatched name comes back as an honest not-found result explaining why, listing candidates where relevant, it's never guessed. - For Monitor mode, prefer the numeric `visaId` over a name in `targets`, IDs are the stable identity, names occasionally get relabelled by Immigration NZ. - Bulk lookups (`targets`) are faster than repeated single-visa runs, they're all fetched in one Actor run. - For ongoing monitoring, schedule the Actor (Apify's built-in Schedules) monthly rather than daily, Immigration NZ 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 Immigration New Zealand's own public processing-time checker tool uses to populate itself. Immigration NZ's content is licensed under Creative Commons Attribution 3.0 New Zealand, with no resale or scraping prohibition found. **Does this track my own personal visa application?** No, and this is deliberate. Immigration NZ's real-time application tracking requires your own logged-in RealMe/portal access, this Actor only reports the *aggregate, published* processing-time figures per visa type, the same numbers everyone applying for that visa can already see on the government's own tool, just structured and monitorable. **What does "not found" mean here?** Either the visa name you gave didn't match anything (or matched more than one visa, an ambiguous result is never silently guessed), or the visa ID is wrong, or Immigration NZ currently publishes no figure for that visa at all. Run with `listAvailableVisas` on to confirm the exact current names and IDs. **How current is the data?** Immigration NZ 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 "expected decision" window a real case status?** No, and this matters: read it carefully before relying on it. Immigration NZ's own processing-time tool never asks its server for your application date at all, the timeline it shows you is worked out entirely in your browser by adding the published working-day percentiles to whatever date you type. This Actor's client tracking mode runs that exact same calculation server-side and repeatably, it is not a new estimate methodology, and it is not a real case status either, Immigration NZ doesn't publish one on any no-login endpoint we could find. One real limitation, stated plainly rather than hidden: the calculation excludes weekends but does not exclude New Zealand public holidays (no confirmed official machine-readable holiday feed), so treat the window as a close estimate, slightly optimistic around Christmas/New Year and other holiday clusters, not exact. 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 Immigration New Zealand's official processing time checker tool, licensed under Creative Commons Attribution 3.0 New Zealand. This Actor is not affiliated with or endorsed by Immigration New Zealand or the New Zealand Government.* # Actor input Schema ## `visaName` (type: `string`): The visa's name as Immigration NZ publishes it, e.g. 'Skilled Migrant Category Resident Visa'. Matched case-insensitively, exact match first, then a unique substring match. Don't know the exact name? Run once with 'List all available visas' turned on instead, or use 'Visa ID' below if you already have the numeric ID from a previous run. ## `visaId` (type: `string`): The numeric ID Immigration NZ uses internally for this visa (returned by 'List all available visas', or by a previous lookup's visaId field). Takes priority over 'Visa name' above if both are given, and skips the name-matching step entirely. ## `targets` (type: `array`): A list of visas to check, one per line, each either a visa name (matched the same way as 'Visa name' above) or a numeric visa ID. Required for Monitor mode (that's what gives each visa a stable identity to track over time). Also the fastest way to check many visas in one run. Don't know the exact names? Run once with 'List all available visas' turned on first. ## `monitorMode` (type: `boolean`): When true, the Actor remembers each visa's last-seen 50th/80th percentile processing times and reports only what changed since the last check, or a cheap no-change confirmation. Schedule this Actor to run monthly with the same targets and watchlistId (Immigration NZ updates these figures roughly monthly). Requires visaName, visaId 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 Immigration NZ publishes a processing time for (130+), with its exact name and numeric ID, so you can find what to use above. This reference lookup is never charged. ## `clients` (type: `array`): Track your own caseload: one row per client with their visa and application date. Ignores every other input when used. Returns the current percentile figures plus the same estimated decision-date window Immigration NZ's own tool shows you, worked out from the application date you give (a plain working-days calculation, weekends excluded; NZ public holidays are not accounted for, so treat the window as a close estimate, not exact). Each row: {"clientLabel": "your own reference, e.g. a name or file number", "visaName": "Skilled Migrant Category Resident Visa" (or use "visaId" instead if known), "applicationDate": "2026-03-01"}. ## Actor input object example ```json { "visaName": "Skilled Migrant Category Resident Visa", "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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "visaName": "Skilled Migrant Category Resident Visa" }; // Run the Actor and wait for it to finish const run = await client.actor("nerolabs/nz-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "visaName": "Skilled Migrant Category Resident Visa" } # Run the Actor and wait for it to finish run = client.actor("nerolabs/nz-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 '{ "visaName": "Skilled Migrant Category Resident Visa" }' | apify call nerolabs/nz-visa-processing-monitor --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,nerolabs/nz-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 ` 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/q00uheLZChSaaG1Ap/builds/DWgcdHZ7BfnDVDU6b/openapi.json