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

**Create a site in a CoreCluster.** Create a site in one of your CoreClusters: fresh installs the platform, empty makes an empty site to migrate into. Use corestack_in_corecluster_site_create when the company has a CoreCluster with space (check corecluster_capacity_check), otherwise corestack_site_create. Scope: write. Also needs exec when reveal_to_agent is true. Long-running: answers with a task. The secret opens in the person's browser; set reveal_to_agent to true to receive it yourself (needs exec).

- Scope: `write`
- Also needs `exec` when the new environments' HTTP-auth logins
- Runs as a task: yes
- Returns a secret only when `reveal_to_agent` is set

## When to use it

Create a site in one of your CoreClusters: fresh installs the platform, empty makes an empty site to migrate into. Use corestack_in_corecluster_site_create when the company has a CoreCluster with space (check corecluster_capacity_check), otherwise corestack_site_create.

With `http_auth: true` the site asks visitors for a password from its first minute: it is created behind HTTP authentication (one whole-site rule, one generated login), so its preview address never answers anyone without it. The login is handed over like a new environment's: a link to the secret page in the person's browser, or the value with `reveal_to_agent` and exec; later, corestack_http_auth_reveal_password shows it again. Change or remove it afterwards with corestack_http_auth_update. Use it for any site that will hold data that is not public yet, such as a copy or a migration.

When another change in the same region is starting at that moment, the create waits for it instead of being refused: it is accepted at once, its operation stays `pending` with the `status_label` "Waiting for another change to finish. This carries on by itself." (the words the Control Panel shows), and it carries on by itself within a few minutes. Do not send it again. The task's status reads the same words while it waits.

When its DNS records cannot be published yet (Cloudflare busy, or a platform DNS problem for Corefinity to fix), the create waits at its `dns` step instead of failing: its operation stays `pending` with the `status_label` "Waiting for DNS", and the task's status reads the same words. It is tried again every minute and goes on by itself; do not send it again.

When the region has no room for the new site yet, the create is not refused: it is accepted, waits briefly for room (`capacity_being_added`, "Setting up your site. This can take a little longer.") and then continues by itself. Do not retry it or create it again; follow it as usual.

When the region has no room for the site's disk yet, the site waits at its first step until there is, however long that takes: it carries on by itself (corestack_site_provisioning_get shows it at its first step meanwhile), so do not create it again.

With `content: copy`, follow the copy with corestack_operation_timeline_get on the new website's `provision` operation. The task names that operation on this answer, on corestack_task_get and on a login round's `work`: as `work.id` of an `operation` work without `environments`, and as `work.operation_id` with them. That read shows the copy's steps. While `fast_copy` is on, this tool and that read draw the copy progress view; for a website that is not a copy the view says so and shows no steps.

A site whose platform address (`<domain>-<company>.cfstack.io`) another site already uses is refused `in_use` before anything is made, naming the address: choose another domain, or contact Corefinity support. The same goes for an environment created with the site: the whole create is refused. If the domain is still held by an earlier create of it that failed and is being cleaned up, the call waits for that clean-up (up to about 20 seconds) and then creates the site; `cleaning_up` is answered only when it has not finished by then: try again in a minute.

A new site never fails while its certificate is issued: when Let's Encrypt is slow or limits new accounts, the task keeps waiting, for up to a few hours, and corestack_site_operation_get and corestack_site_progress_get say "Certificate on its way" (note `certificate_on_its_way`) until it carries on by itself.

A create that stops on a temporary problem (the platform, its DNS or its SSH gateway not ready in time) is tried again automatically, at most three times, a few minutes apart; follow it with corestack_site_provisioning_get (or corestack_site_progress_get when it was made with environments) and corestack_site_operation_get (`notes`) instead of creating it again.

When the region's servers are not taking new sites for the moment (being set up or replaced), the site is created and waits, then goes on by itself once they are; there is nothing to retry. With `environments`, an environment is never refused because the region's staging servers are not ready yet: it is created on the region's production servers instead.

Automatic upgrades: on a CoreCluster whose company turned them on, a create that would take the cluster past 90 % of its package first buys the smallest add-on raise that makes room (or, when add-ons cannot, the next package), within the company's monthly limit, and goes ahead. When the server a create needs cannot be added in the region yet, or the create needs a larger server than any its CoreCluster runs on today, or the region's servers are not taking new sites for the moment, the create is accepted and waits, and nothing is bought while it waits: the upgrade is made once it can go on, within the monthly limit as it is then. An automatic upgrade adds room on the servers the CoreCluster runs on, never a larger server. Each upgrade stays on the monthly bill until it is changed back. A create that buys its upgrade at once is refused over the limit with `capacity_blocked`, naming the limit; a create that waited goes ahead even when the upgrade cannot be made once its wait ends (automatic upgrades turned off, or the limit reached), and Corefinity is told. When the region cannot take the server the create needs at all (not merely yet), nothing is bought and it is refused exactly as with automatic upgrades off: without `environments`, `invalid_arguments` on `tier`; with them, the first refusal its rows meet in order (the site, then each environment): `compute_blocked` for a server the region cannot take, `capacity_blocked` for a row past the package. See corestack_company_auto_upgrades_get.

A site that needs a new server in the region while changes to cluster capacity are paused for planned maintenance is not refused: it is created and waits for its server, then goes on by itself once the pause ends; there is nothing to retry. Likewise, while the cluster is moving onto its new servers a new site is created and waits for the move to finish, then goes on by itself (`pool_retiring` is no longer answered).

With `environments`, a site whose environments cannot be made in the same admission is not refused for that: before the cluster's upgrade night (the cluster is not on its new servers yet), or while creating environments with the site is switched off, the site is created on its own and each environment is added after the site is ready. The answer is the same task; each environment in it carries `queued_after_site: true` and the note "Added after the site is ready.", waits while the site is being created and starts by itself once it is. corestack_site_progress_get shows each one waiting (`state` `todo`, the same `note`); while creating environments with the site is switched off, the task names corestack_site_provisioning_get for the site instead, and corestack_task_get follows both. Every environment is checked before the site is created, so a name the create refuses is refused with nothing written. An environment that cannot be added once the site exists is named in the task's status message ("Not added: <name> (<reason in words>)") on every poll, in the task's `work.not_queued` (`slug`, `reason`) from the first answer and on every corestack_task_get, and as `not_queued` (`slug`, `reason`, `message`) in its result; add it later with corestack_environment_create. Do not create the site again.

## Inputs

- `cluster_id` (integer, ≥ 1, required)
- `platform` (one of `wordpress`, `laravel`, `magento2`, `shopware`, required)
- `domain` (string, 4–253 characters, required): The site's domain, without www.
- `tier` (string, up to 16 characters, required): A tier the platform and the package offer.
- `content` (one of `fresh`, `empty`, required; `copy` too while `fast_copy_new_site` is on): fresh: install the platform; empty: an empty site to migrate into; copy: a copy of `source`.
- `php_version` (string, up to 8 characters)
- `mariadb_version` (string, up to 8 characters)
- `search` (boolean): Shopware only: search (OpenSearch) on or off. Left out, the size decides (on from 16 GB); on needs 8 GB or more. The index is built and checked before the storefront searches it.
- `node_major` (integer, 10–99): The Node.js major (corestack_site_provisioning_options lists each platform's, with its status). Left out, the default for new sites.
- `node_acknowledge` (array of one of `eol`, up to 1 items): ["eol"] once the person knows the chosen Node.js major is end of life (refused with ack_required otherwise).
- `fresh` (object): With content fresh: the first admin and the site's title.
  - `admin_email` (string, up to 255 characters)
  - `admin_username` (string, up to 32 characters)
  - `site_title` (string, up to 255 characters)
  - `locale` (string, up to 16 characters)
- `http_auth` (boolean): true: the site asks visitors for a password from its first minute (one generated login, handed over once). Left out or false, the site is created open, as before.
- `edition` (one of `open_source`, `mage_os`, `commerce`; only while `app_versions` is on and an edition is offered): magento2 only; the edition from corestack_app_versions_list. Left out, the platform's default edition.
- `app_version` (string; only while `app_versions` is on): The line key from corestack_app_versions_list (for example 2.4.8). Left out, the platform's default line.
- `acknowledge` (array of one of `eol`; only while `app_versions` is on): ["eol"] once the person knows the chosen line is end of life (refused with `ack_required` otherwise).
- `varnish` (object; only while new Magento 2 sites are born with Varnish): Magento 2 only: `{enabled: true|false, version?}`. Left out, the site is born with Varnish on the default version (7.7) in front of Magento; `enabled: false` uses Magento's built-in full-page cache instead and the site stays that way until the person switches Varnish on. `version` is one corestack_site_provisioning_options lists as allowed for the Magento version being installed (`version_unsupported` otherwise); a size with no room for Varnish is `varnish_too_small`.
- `source` (object; only while `fast_copy_new_site` is on): With content copy: the environment to copy, one of the company's (corestack_copy_preview shows what the copy brings and its price), as `{environment_id}` or the API's `{type: "environment", environment_id}`. Platform and versions follow it: leave the version, `fresh`, Node.js and line keys out; a `platform` sent must be the source's. While restoring anywhere and restoring into a new website are switched on, `source` may instead be `{type: "snapshot", snapshot_id}`: any snapshot of the company's websites (corestack_company_snapshots_list), whose platform and versions the new website follows; it is never anonymised (that is corestack_snapshot_restore_to's).
  - `type` (`environment`, the default; another type is `invalid_arguments`)
  - `environment_id` (integer): The environment's row (a website's production row or one of its environments).
- `environments` (array of objects, up to 10 items): Environments created with the site, in one admission ({name, tier?}; tier defaults to the site's).
  - `name` (string, 1–40 characters, required): 1–40 characters, without < or >.
  - `tier` (string, up to 16 characters)
- `reveal_to_agent` (boolean, default `false`): Return the secret to you instead of opening it in the person's browser. Needs exec.

### Input schema

```json
{
  "additionalProperties": false,
  "properties": {
    "acknowledge": {
      "items": {
        "enum": [
          "eol"
        ],
        "type": "string"
      },
      "type": "array"
    },
    "app_version": {
      "type": "string"
    },
    "cluster_id": {
      "minimum": 1,
      "type": "integer"
    },
    "content": {
      "description": "fresh: install the platform; empty: an empty site to migrate into.",
      "enum": [
        "fresh",
        "empty"
      ],
      "type": "string"
    },
    "domain": {
      "description": "The site's domain, without www.",
      "maxLength": 253,
      "minLength": 4,
      "type": "string"
    },
    "edition": {
      "enum": [
        "open_source"
      ],
      "type": "string"
    },
    "environments": {
      "description": "Environments created with the site, in one admission ({name, tier?}; tier defaults to the site's).",
      "items": {
        "additionalProperties": false,
        "properties": {
          "name": {
            "description": "1–40 characters, without < or >.",
            "maxLength": 40,
            "minLength": 1,
            "type": "string"
          },
          "tier": {
            "maxLength": 16,
            "type": "string"
          }
        },
        "required": [
          "name"
        ],
        "type": "object"
      },
      "maxItems": 10,
      "type": "array"
    },
    "fresh": {
      "additionalProperties": false,
      "description": "With content fresh: the first admin and the site's title.",
      "properties": {
        "admin_email": {
          "maxLength": 255,
          "type": "string"
        },
        "admin_username": {
          "maxLength": 32,
          "type": "string"
        },
        "locale": {
          "maxLength": 16,
          "type": "string"
        },
        "site_title": {
          "maxLength": 255,
          "type": "string"
        }
      },
      "type": "object"
    },
    "http_auth": {
      "description": "true: the site asks visitors for a password from its first minute (one generated login, handed over once).",
      "type": "boolean"
    },
    "mariadb_version": {
      "maxLength": 8,
      "type": "string"
    },
    "node_acknowledge": {
      "description": "[\"eol\"] once the person knows the chosen Node.js major is end of life (refused with ack_required otherwise).",
      "items": {
        "enum": [
          "eol"
        ],
        "type": "string"
      },
      "maxItems": 1,
      "type": "array"
    },
    "node_major": {
      "description": "The Node.js major (corestack_site_provisioning_options lists each platform's, with its status). Left out, the default for new sites.",
      "maximum": 99,
      "minimum": 10,
      "type": "integer"
    },
    "php_version": {
      "maxLength": 8,
      "type": "string"
    },
    "platform": {
      "enum": [
        "wordpress",
        "laravel",
        "magento2",
        "shopware5"
      ],
      "type": "string"
    },
    "reveal_to_agent": {
      "default": false,
      "description": "Return the secret to you instead of opening it in the person's browser. Needs exec.",
      "type": "boolean"
    },
    "search": {
      "description": "Search (OpenSearch) on or off, on a platform that offers it.",
      "type": "boolean"
    },
    "tier": {
      "description": "A tier the platform and the package offer.",
      "maxLength": 16,
      "type": "string"
    },
    "varnish": {
      "properties": {
        "enabled": {
          "type": "boolean"
        },
        "version": {
          "type": "string"
        }
      },
      "type": "object"
    }
  },
  "required": [
    "cluster_id",
    "platform",
    "domain",
    "tier",
    "content"
  ],
  "type": "object"
}
```

## Refusals

- `provisioning`: the site is still being created; wait for corestack_site_provisioning_get to finish.
- `capacity_blocked`: there is not enough capacity for this; check corecluster_capacity_check or choose another size.
- `invalid_arguments` on `tier` (without `environments`): the site would take the CoreCluster past its package, and automatic upgrades are off or cannot make room for it in the region; choose a smaller size, or see corestack_company_auto_upgrades_get.
- `placement`: the site cannot be placed there; choose another placement. A PHP, Shopware or Shopware 5 site is only created on a cluster on compute ("Sites of that platform cannot be created on this cluster yet. Contact support."): create it on another of the person's clusters, or ask Corefinity support.
- `node_major_existing_only`: that Node.js version is only kept for rows that already use it; choose a supported one.
- `node_platform_minimum`: the platform needs a newer Node.js version; choose one at or above its minimum.
- `ack_required`: the change needs the person's acknowledgements first; `required[]` lists them — confirm with the person, then call again with them.
- `search_too_small`: search needs at least 8 GB; turn search off first or choose Medium (8 GB) or larger.
- `invalid_arguments` on `source.environment_id` or `source.snapshot_id` (content `copy`): "This WordPress site is built with Bedrock, so it can only be copied to a site that deploys the same way. For a staging copy, use a branch (Git) environment." A new website made from a copy deploys manually, so a WordPress site built with Bedrock that deploys from Git is not copied into one.
- `legacy_search` on `source.environment_id` or `source.snapshot_id` (content `copy`; message: "This site's search runs on a temporary older engine. Switch the store to the OpenSearch module first."): the source's search runs on a temporary older engine, so a new website is not made from it. Tell the person to switch the store to the OpenSearch module first.
- `invalid_arguments` on `http_auth` ("This platform cannot protect a site with a password while it is created. Create the site, then turn HTTP authentication on."): the platform's templates are older than HTTP authentication; create the site without `http_auth`, then turn it on with corestack_http_auth_update.
- `rate_limited`: the person has created as many sites this hour as the limit allows (100 by default, shared with the Control Panel and the API). A create that is refused does not count. Wait `retry_after_seconds`, then call again.
- `invalid_arguments` on `content` ("PHP sites start empty: deploy your code"), or on `app_version`, `edition` or `acknowledge` ("The <field> field is not part of this request.", naming it): PHP has no installer and no versions to choose; create it with `content: empty` and leave those inputs out.
- `invalid_arguments` on `platform` or `tier` ("<package> does not offer <platform> sites on this cluster", or "<package> does not offer <size> on this cluster"; where a larger package offers it the sentence adds "Upgrade to <that package> or larger to add one."): the cluster's package does not offer that site. Choose another platform or size, or move the cluster to a package that offers it first (corecluster_package_change); nothing was created.
- 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_in_corecluster_site_create",
  "arguments": {
    "cluster_id": 812,
    "platform": "wordpress",
    "domain": "example.co.uk",
    "tier": "M",
    "content": "fresh",
    "http_auth": true
  }
}
```

## What it installs

Left out, `app_version`, `php_version` and `mariadb_version` take the defaults, and a default that cannot be installed on a new site yet never refuses the create: a release that has not finished testing installs the newest older release of the same line that has and carries the same security fixes (a line without that data never falls back to an older release), a default line that is held, has ended or has no build for the placement installs the next older line of its edition that carries them, and a PHP or MariaDB version not yet open to new sites takes the newest one that is. Each such choice is listed as `{field, from, to, reason, message}` in `create_fallbacks`: on the finished task's result, while the task runs on corestack_site_progress_get (with `environments[]`, or corestack_site_create) or corestack_site_provisioning_get (without), and afterwards on corestack_site_get's `site`. Once the PHP version a site could not be created on opens to new sites, its `php_version` entry carries `now_available: true` and says so in one sentence; the site stays on what it was created with until the owner switches it (corestack_php_version_change). Tell the person its `message`. A version you name is checked as before and refused if it cannot be installed.

When no release of the line has both finished testing and carries the newest security fixes, the create is accepted and waits instead of being refused: nothing is installed until a release qualifies, and then the site installs exactly what a create made at that moment would (the line, edition, PHP and MariaDB versions are kept). While it waits, `version_wait` (`{line, edition, pin, label, reason, since, message}`) is on corestack_site_progress_get or corestack_site_provisioning_get and on corestack_site_get's `site`, and the task keeps working with its `message` as the status, also when another change was starting at that moment. Tell the person its `message`. If staff hold the line meanwhile it keeps waiting and `reason` says why. A version you name waits the same way; it never moves to another line. To stop waiting, delete the site with corestack_site_delete: the waiting create is cancelled and its task ends `cancelled`.

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.

When no PHP version of the site's list is open to new sites yet (just after a PHP security update, before its tested release is opened), the create is not refused: it is accepted and waits for the PHP version it would use (the one you name, or the default), then goes on by itself once that version is open, never on another one. `version_wait` then has `kind` `php` and `php` (the version it waits for), its `reason` is `runtime_not_open` and its `message` reads "Waiting for PHP 8.3 to be available for new sites. Your site will be set up as soon as it is." Do not create it again; tell the person its `message`. While any PHP version of the list is open, one that is not is refused `php_version` as before: choose an open one (corestack_site_provisioning_options lists them, and says `php_wait` when none is).

A copy (`content` `copy`) of a site whose PHP version is not open to new sites yet is not refused either: a copy keeps the versions of the site it is copied from, so it waits for that version (`version_wait` with `kind` `php`), then goes on by itself once it is open. If by then the copy can no longer be made as it was planned (the storage server it was planned on is being emptied, or the site it copies has moved), it keeps waiting with the status "Waiting for our team to prepare the copy"; it is never failed. The snapshot a copy is made from cannot be deleted until the copy has finished.

A platform with no installer of its own (PHP, while it is offered) starts empty: send `content: empty` and no `fresh`, `app_version`, `edition` or `acknowledge`; the site takes the platform's default PHP and MariaDB versions unless you name them. The person then deploys their own code to it, as to any empty site.

## Prompt

```text
Using the Corefinity MCP server, call corestack_in_corecluster_site_create with cluster_id 812, platform wordpress, domain example.co.uk, tier M, content fresh, http_auth true. (Create a site in a CoreCluster.) Tell me what it returned.
```

## The same task elsewhere

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