---
title: "corestack_site_progress_get"
url: https://docs.corefinity.com/mcp/tools/corestack_site_progress_get
type: tool
last_updated: 2026-11-13
feature: site-create
related:
  - https://docs.corefinity.com/api/reference/sites/get-site-progress.md
  - https://docs.corefinity.com/guides/sites/create-and-manage/create-a-site.md
---
# corestack_site_progress_get

**CoreStack create progress.** Follow a new CoreStack site from its create to ready: its stages, its environments, whether a server is being prepared for it, and why it failed if it did. Scope: read.

- Scope: `read`
- Runs as a task: no

## When to use it

Follow a new CoreStack site from its create to ready: its stages, its environments, whether a server is being prepared for it, and why it failed if it did.

When the platform needs more capacity for the site, the `starting` stage stays `current` with the detail "Setting up your site. This can take a little longer." while that capacity is prepared, and `state` stays `creating`. The create carries on by itself; read again to follow it. If it still has no room after about two hours, that attempt stops with `no_room`, a temporary problem, so it is tried again automatically as below; `failed.reason` reads `no_room` only once nothing will try it again.

`operation.notes` (`[{code, text}]`, as corestack_site_operation_get answers them) says what the create did differently on purpose: `platform_address_changed` when the site's usual platform address was already used by another site, so the site and its environments were created on the next free one ("The usual platform address for this site was already in use, so it uses … instead."). Nothing needs to be done.

While the site's certificate is still being issued, `state` stays `creating`, the `starting` stage is `current` with `detail` "Certificate on its way", and the operation's `notes` carry `certificate_on_its_way` with the same words. It is not a failure: the create carries on by itself, for up to a few hours, and nothing needs to be done again.

When the create installs something in place of a default not yet open to new sites, `create_fallbacks` lists each choice (`{field, from, to, reason, message}`, `to` being what is installed) and the `installing` stage's `detail` says it in words, in the past tense, as of the create ("PHP 8.3 was not available for new sites when this site was created, so it was set up with PHP 8.4."). A `php_version` entry also carries `now_available`, worked out on every read and never stored: true once the PHP version the create could not install (`from`) is open to new sites and the site does not run it yet, and its `message` then reads "PHP 8.3 is now available. You can switch this site to it in its PHP settings." (8.3 being `from`). The site is never moved for it: switching is the owner's choice (corestack_php_version_change).

While the create waits for a release of its line to finish testing (none has both passed and carries the newest security fixes yet), `version_wait` (`{line, edition, pin, label, reason, since, message}`) is present, `state` stays `creating` and the current stage's `detail` is its `message`. Nothing is installed until a release qualifies; the create then goes on by itself.

Whenever the Control Panel requests the release's security testing itself, `version_wait` also has `testing` (`{state, since}`) and `overdue`, and `message` always reads the same state. `testing.state` is `requested` (the testing is asked for and has not started), `running` (the release is being tested), `awaiting_staff` (our team runs this release's security testing) or `team_review` (our team confirms the version: the testing has ended, the wait is for another `reason`, or it passed its bound; when the testing passed, the create goes on by itself shortly); `testing.since` is when that state began. `overdue` turns `true` once the create has waited longer than the bound our team sets: `testing.state` then reads `team_review`, and the create keeps waiting, is never failed by the bound and still goes on as soon as a release qualifies.

`version_wait` also answers a create waiting for its PHP version (none of its list was open to new sites): it then starts with `kind` `php` and `php` (the version it waits for), its `reason` is `runtime_not_open` (`runtime_not_offered` or `node_not_adopted` while our team must act), and `line`, `pin` and `label` are null for a site without an application version line. It goes on by itself once that version is open; tell the person its `message`.

A create that stops on a temporary problem is tried again automatically, at most three times, a few minutes apart. While an attempt is still to come, `state` stays `creating` and the stage it stopped at stays `current`, its `detail` saying when it will be tried again; `operation.notes` carries the same words (`auto_retry_scheduled`, then `auto_retry_attempt` on the new attempt) and `retried.by.name` reads "Corefinity (automatic)". `state` is `failed` only once nothing will try it again (`auto_retry_exhausted`, or a cause a retry cannot change). Poll this tool rather than creating the site again.

`payment` is null unless the site was created before its company had a payment method. Then it carries `method_needed`, `add_by` (the date to add one by), `message` (the Control Panel's words, for example "This site was created before your account had a payment method. Add a card or a Direct Debit mandate by 5 November 2026.") and `href`. Only people who can see the company's billing read it. It goes once a card or a Direct Debit mandate is added, and when the site's creation fails and will not be tried again automatically (it comes back if a later retry makes the site ready).

## Inputs

- `site_id` (integer, ≥ 1, required): The created site, or one of its environments.

While a create waits for its DNS records to be published (Cloudflare busy, or a platform DNS problem for Corefinity to fix), `state` stays `creating`, the `committed` stage is `current` with the `detail` "Waiting for DNS. The step will be tried again." and `operation.status_label` is "Waiting for DNS". It goes on by itself; poll rather than creating the site again.

### Input schema

```json
{
  "additionalProperties": false,
  "properties": {
    "site_id": {
      "description": "The created site, or one of its environments.",
      "minimum": 1,
      "type": "integer"
    }
  },
  "required": [
    "site_id"
  ],
  "type": "object"
}
```

## Refusals

- `state`: the object is not in a state this applies to; read it again.
- The refusals every tool can answer: `invalid_arguments`, `tenant_mismatch`, `scope_required`, `pin_refused`, `rate_limited`, `temporarily_unavailable`, `internal_error` (corestack://guides/how-this-server-works).

## Example

```json
{
  "name": "corestack_site_progress_get",
  "arguments": {
    "site_id": 4211
  }
}
```

## Prompt

```text
Using the Corefinity MCP server, call corestack_site_progress_get with site_id 4211. (CoreStack create progress.) Tell me what it returned.
```

## The same task elsewhere

- Endpoint: [GET /api/corestack/sites/{site}/progress](https://docs.corefinity.com/api/reference/sites/get-site-progress.md)
- Guide: [Create a site](https://docs.corefinity.com/guides/sites/create-and-manage/create-a-site.md)
