Everything an AI can call

Connecting

The MCP server is at https://mcp.spaicely.com/mcp (Streamable HTTP, stateless). Clients find the authorization server through the protected resource metadata, register themselves with dynamic client registration, or use the URL of a client ID metadata document as their client_id, and sign in with the authorization code flow and PKCE (S256). There are no client secrets. On the consent screen the person chooses the account, the sites and the scopes; a token never allows more than that person's own role on a site.

Domain search needs no account: https://mcp.spaicely.com/mcp/public, or the HTTP API below.

Claude Code

Add the server for yourself with claude mcp add --transport http spaicely https://mcp.spaicely.com/mcp, then run /mcp and sign in. On a machine without a browser: claude mcp login spaicely --no-browser, which prints a URL to open elsewhere.

For everyone working on a project, put it in .mcp.json at the root of the repository. Each person signs in with their own account. Keep "type": "http": without it Claude Code skips the entry.

{
  "mcpServers": {
    "spaicely": { "type": "http", "url": "https://mcp.spaicely.com/mcp" }
  }
}

Or install the plugin, which brings the server and our guides for building and running a site and finding a domain in one go. The prompts are then called /mcp__plugin_spaicely_spaicely__new_site and so on. Source: github.com/spaicely/agent-plugins.

claude plugin marketplace add spaicely/agent-plugins
claude plugin install spaicely@spaicely

The server brings prompts that work as commands: /mcp__spaicely__new_site builds and publishes a new site, /mcp__spaicely__launch_check goes over a site before launch. Deleting a site, registering or moving a domain, changing nameservers, removing a form and changing the people on an account always ask for your approval, even in auto mode. sites.files.get returns up to 500,000 characters in the conversation; larger answers Claude Code keeps in a file.

Codex and Gemini CLI

The same plugin works in Codex and Gemini CLI, with the server and the three guides. Both sign in with OAuth in the browser on first use.

codex plugin marketplace add spaicely/agent-plugins
gemini extensions install https://github.com/spaicely/agent-plugins

In Codex, install Spaicely from the plugin list afterwards. In Gemini CLI, run /mcp auth spaicely to sign in and gemini extensions update spaicely for a newer version. Without the plugin, add the server in Gemini CLI's settings.json as "spaicely": {"httpUrl": "https://mcp.spaicely.com/mcp"} under mcpServers.

What the server tells every client: Spaicely hosts static websites on the customer's own domain in the EU. You act for one person and one account; start with account.whoami to learn which sites you may see and what you may change; with no site yet, sites.create makes one on that account. Your rights are never wider than the person's role on a site. Purchases always need a second call with a confirmation token, after the person agreed. The person chooses per kind of action whether you may do it yourself, must ask first, or may not (account.whoami lists them as ai_permissions). A call that must be asked first answers with approval_required and a url: give the person that link, do not repeat the call, and read the outcome with approvals.status once they say they decided. The call runs exactly as you sent it. Give every site its own 404.html at the root, in the style and language of the site: visitors get it for any address that does not exist. Without one they get a plain page of ours in the language of the lang attribute of index.html. Every site also needs robots.txt, sitemap.xml and llms.txt at the root, an icon, and on each page its own title, meta description, lang, canonical link and Open Graph tags for link previews, all with full https URLs on the site's domain; describe the business in JSON-LD. The full checklist with examples: https://spaicely.com/skills/en/site-building/SKILL.md (also nl, de, fr). Running a site (versions, rollback, domain, DNS, mail forwarding, people, plan): https://spaicely.com/skills/en/site-management/SKILL.md. After publishing, the hints in sites.versions say what is still missing. Once the hosting is paid, a published site is also at its own address (address in account.whoami), to share before a domain is connected. A static site can still take messages, signups and payments: scripts.enable adds a form handled by Spaicely and gives the HTML to put in a page. Kinds: contact (mail to the owner), signup (a list with double opt-in), download (a file under _private/ for the visitor's details), coupon (a discount code; one for everyone, a list, or codes with dates such as a code per week) and donation (any plan: amounts paid to the owner's own Stripe account, a progress bar from progress_url). A download or coupon form can take a price. Use these instead of a form or payment service elsewhere. A site with the Shop plan sells through shop.setup: Stripe Checkout on the owner's own Stripe account, prices from a products file in the site (at most 500 products). Payments carry a 2% commission. A person who may change files but not publish asks for approval with sites.review.request (Pro and Shop plans); sites.stats gives visits without cookies. A partner proposes a domain to a customer with domains.propose and hands a finished site over with sites.handover. sites.subscription shows and starts or switches a site's hosting plan; account.billing holds the billing details every purchase needs. Mail to a connected domain can be forwarded to mailboxes the person already has (info@ to their Gmail): mail.forward.enable, then mail.forward.add; EUR 1.50 (GBP 1.30, USD 1.75) a month per address, Site 1, Pro 5, Shop 10. Answering as info@ is not possible yet. The prompts new_site and launch_check describe how we like a site built and checked; move_site rebuilds a site from elsewhere, such as WordPress, with the same pages and addresses. Spaicely adds tools over time. Fetch the tool list again when you can; when a tool named here or on https://spaicely.com/developers/ is not in your list, ask the person to reconnect the Spaicely connector (in claude.ai: Settings > Connectors), which loads the current list.

Connecting from code

Every MCP SDK can talk to Spaicely; you don't need any software from us. The examples search for a domain on the public server, which needs no account, and then show how to send an access token to https://mcp.spaicely.com/mcp, the signed-in server. Each one was run against our server before it went on this page.

npm install @modelcontextprotocol/sdk

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const client = new Client({ name: "my-app", version: "1.0.0" });
await client.connect(new StreamableHTTPClientTransport(new URL("https://mcp.spaicely.com/mcp/public")));

const result = await client.callTool({
  name: "domains.search",
  arguments: { names: ["bakkerijjansen"], extensions: ["nl", "com"] },
});
for (const found of result.structuredContent.results) console.log(found.domain, found.status);
await client.close();

// signed in: the access token as a header
new StreamableHTTPClientTransport(new URL("https://mcp.spaicely.com/mcp"), {
  requestInit: { headers: { Authorization: `Bearer ${token}` } },
});

pip install "mcp>=2"

import asyncio

from mcp import Client


async def main():
    async with Client("https://mcp.spaicely.com/mcp/public") as client:
        result = await client.call_tool("domains.search", {"names": ["bakkerijjansen"], "extensions": ["nl", "com"]})
        for found in result.structured_content["results"]:
            print(found["domain"], found["status"])


asyncio.run(main())

# signed in: the access token as a header
from mcp.client.streamable_http import create_mcp_http_client, streamable_http_client

http = create_mcp_http_client(headers={"Authorization": f"Bearer {token}"})
async with Client(streamable_http_client("https://mcp.spaicely.com/mcp", http_client=http)) as client:
    ...

go get github.com/modelcontextprotocol/go-sdk

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/modelcontextprotocol/go-sdk/mcp"
)

func main() {
	ctx := context.Background()
	client := mcp.NewClient(&mcp.Implementation{Name: "my-app", Version: "1.0.0"}, nil)
	session, err := client.Connect(ctx, &mcp.StreamableClientTransport{Endpoint: "https://mcp.spaicely.com/mcp/public"}, nil)
	if err != nil {
		log.Fatal(err)
	}
	defer session.Close()

	result, err := session.CallTool(ctx, &mcp.CallToolParams{
		Name:      "domains.search",
		Arguments: map[string]any{"names": []string{"bakkerijjansen"}, "extensions": []string{"nl", "com"}},
	})
	if err != nil {
		log.Fatal(err)
	}
	for _, found := range result.StructuredContent.(map[string]any)["results"].([]any) {
		domain := found.(map[string]any)
		fmt.Println(domain["domain"], domain["status"])
	}
}

// signed in: an http.Client that adds the access token
type bearer struct{ token string }

func (b bearer) RoundTrip(req *http.Request) (*http.Response, error) {
	req = req.Clone(req.Context())
	req.Header.Set("Authorization", "Bearer "+b.token)
	return http.DefaultTransport.RoundTrip(req)
}

transport := &mcp.StreamableClientTransport{
	Endpoint:   "https://mcp.spaicely.com/mcp",
	HTTPClient: &http.Client{Transport: bearer{token}},
}

cargo add rmcp --features client,transport-streamable-http-client-reqwest,reqwest
cargo add tokio --features full
cargo add serde_json

use rmcp::{
    ServiceExt,
    model::CallToolRequestParams,
    transport::{StreamableHttpClientTransport, streamable_http_client::StreamableHttpClientTransportConfig},
};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = StreamableHttpClientTransportConfig::with_uri("https://mcp.spaicely.com/mcp/public");
    let client = ().serve(StreamableHttpClientTransport::from_config(config)).await?;

    let arguments = json!({ "names": ["bakkerijjansen"], "extensions": ["nl", "com"] });
    let result = client
        .call_tool(CallToolRequestParams::new("domains.search").with_arguments(arguments.as_object().unwrap().clone()))
        .await?;
    for found in result.structured_content.unwrap()["results"].as_array().unwrap() {
        println!("{} {}", found["domain"].as_str().unwrap(), found["status"].as_str().unwrap());
    }
    client.cancel().await?;
    Ok(())
}

// signed in: the access token, without "Bearer "
let config = StreamableHttpClientTransportConfig::with_uri("https://mcp.spaicely.com/mcp").auth_header(token);

bundle add mcp faraday base64

require "mcp"

client = MCP::Client.new(transport: MCP::Client::HTTP.new(url: "https://mcp.spaicely.com/mcp/public"))
client.connect(client_info: { name: "my-app", version: "1.0.0" })

response = client.call_tool(name: "domains.search", arguments: { names: ["bakkerijjansen"], extensions: ["nl", "com"] })
response.dig("result", "structuredContent", "results").each do |found|
  puts "#{found["domain"]} #{found["status"]}"
end

# signed in: the access token as a header
transport = MCP::Client::HTTP.new(url: "https://mcp.spaicely.com/mcp",
                                  headers: { "Authorization" => "Bearer #{token}" })

# 1. which tools are there
curl https://mcp.spaicely.com/mcp/public \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc": "2.0", "id": 1, "method": "tools/list"}'

# 2. call one
curl https://mcp.spaicely.com/mcp/public \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc": "2.0", "id": 2, "method": "tools/call",
       "params": {"name": "domains.search", "arguments": {"names": ["bakkerijjansen"], "extensions": ["nl", "com"]}}}'

# signed in: same requests to /mcp, with the access token
curl https://mcp.spaicely.com/mcp -H "Authorization: Bearer $TOKEN" ...

An access token comes from the OAuth flow described under Calling MCP without a client library; the TypeScript and Python SDKs can run that flow themselves, the TypeScript one through an authProvider on the transport. There are official SDKs for C#, Java, Kotlin, Swift and PHP too, see modelcontextprotocol.io; they work the same way: a Streamable HTTP transport to the address above, then tools/call.

Putting a site live

Spaicely hosts what the AI built; it does not build or template anything. A new version is the full list of files with their SHA-256 (sites.deploy); the answer names the files we do not have yet, which go up with sites.files.put. An AI with the site as a folder on disk calls sites.upload_url and sends one tar.gz instead. Nothing is visible until sites.publish, which switches all visitors at once and can roll back.

We keep the files exactly as uploaded; sites.files.get returns them that way. Visitors get an optimised copy: HTML without comments and indentation, CSS and JavaScript minified, large JPEG and PNG images recompressed and scaled to at most 2560 pixels. A file that would not get smaller goes out as it is. sites.versions shows the savings and hints, each with a fix: images without alt or without a size, and what the site still lacks, from sitemap.xml, robots.txt and llms.txt to a page without its own title, description, canonical link or Open Graph tags.

What we expect of every site, with examples of the head of a page, the sitemap, link previews, structured data and more than one language, is in the skill site-building (also in Dutch, German and French). Give it to the AI that builds the site, or add it to Claude Code as a skill.

How to run a site once it is built (versions and rollback, changing one block of a page, connecting the domain, DNS, mail forwarding, people and roles, approval, handover, the hosting plan) is in the skill site-management (also in Dutch, German and French). The Claude Code plugin brings both skills and the domain search guide.

What the AI may do on its own

Reading is always allowed. For every kind of action that changes something (building, publishing, domain and DNS, forms and shop, visitor data, mail, buying and plans, people and roles, the domain at the registry, deleting, billing details) the person chooses self, ask or never at app.spaicely.com/ai; an account owner can set a minimum for everyone. account.whoami returns these settings as ai_permissions. By default buying, people, mail, the registry, deleting and billing details are ask.

A call whose kind is set to ask does not run. It answers with approval_required, an approval id and a url for the person, who approves in Spaicely with a passkey or a recent sign-in, optionally with "don't ask me again" for that kind. We then run the call exactly as it was sent, with the same token, and approvals.status returns its answer. Do not repeat the call: the same call gives the same approval. A request waits 24 hours; a never kind is refused.

Command line

The Spaicely CLI (open source, MIT) is for people who build their site themselves, with Jekyll, Hugo, Eleventy, Astro or plain HTML, and for AI coding tools that run shell commands, such as Claude Code and Cursor. It is an MCP client of the same server as the AI assistants, so it can do what they can do, with the same rights. Every tool below works through spaicely call, also the ones without a command of their own.

Install

One file, no runtime needed. Every release has binaries for macOS (Apple silicon and Intel), Linux (x64 and arm64) and Windows (x64), a SHA256SUMS file and a build attestation.

macOS

brew install spaicely/tap/spaicely

# or without Homebrew: picks the right binary, checks its SHA-256, puts it in ~/.local/bin
curl -fsSL https://spaicely.com/install.sh | sh

Linux

curl -fsSL https://spaicely.com/install.sh | sh

# another folder than ~/.local/bin
curl -fsSL https://spaicely.com/install.sh | SPAICELY_INSTALL_DIR=/usr/local/bin sh

# Homebrew on Linux works too
brew install spaicely/tap/spaicely

Windows

In PowerShell, without administrator rights:

$dir = "$env:LOCALAPPDATA\Programs\spaicely"
$zip = "$env:TEMP\spaicely.zip"
$url = "https://github.com/spaicely/cli/releases/latest/download/spaicely-windows-x64.zip"
Invoke-WebRequest $url -OutFile $zip
Expand-Archive $zip -DestinationPath $dir -Force
$path = [Environment]::GetEnvironmentVariable("Path", "User")
[Environment]::SetEnvironmentVariable("Path", "$path;$dir", "User")

Open a new terminal afterwards so it sees the new path. In WSL, use the Linux line above.

With Node.js, on any system

npm install -g spaicely      # Node.js 20 or newer
npx spaicely whoami          # or run it without installing

Check, verify, update

spaicely --version

# the download is the build from the repository (needs the GitHub CLI)
gh attestation verify spaicely-darwin-arm64.tar.gz --repo spaicely/cli

brew upgrade spaicely                          # Homebrew
npm install -g spaicely@latest                 # npm
curl -fsSL https://spaicely.com/install.sh | sh   # the script installs the newest release again

Sign in

spaicely login               # opens the browser: the same consent screen as for an AI
spaicely login --no-browser  # over SSH: prints the address to open elsewhere
spaicely whoami              # who you are, which account, which sites
spaicely logout              # revokes the sign-in on the server and forgets it here

The sign-in is kept in ~/.config/spaicely/credentials.json, readable only by you. Messages follow the language of your Spaicely account: Dutch, English, German or French.

From folder to live site

spaicely sites create "Bakkerij Jansen"   # a new, empty site; or `spaicely sites` for the ones you have
cd bakkerij-jansen
spaicely init --site 12        # writes spaicely.toml; recognises Jekyll, Hugo, Eleventy, Astro and Vite
spaicely serve --build         # http://localhost:4000, served the way Spaicely will serve it
spaicely deploy --dry-run      # what would change compared to the live site
spaicely deploy                # build, then upload only what changed, as a new version
spaicely publish               # put the newest version live; asks first
spaicely versions              # every version, with the one that is live
spaicely rollback              # back to the version that was live before

spaicely.toml holds what init found; adjust it as you like:

site = 12                            # or "bakkerijjansen.nl"
dir = "_site"                        # the folder that goes up
build = "bundle exec jekyll build"   # runs before deploy and serve --build
ignore = ["*.map", "drafts/**"]

In one go, without questions: spaicely deploy --publish --yes. --no-build skips the build, --force uploads even when nothing changed, -d uploads another folder.

Domains and DNS

spaicely domains search bakkerijjansen -e nl,com,eu   # no sign-in needed
spaicely domains search bakkerijjansen.nl --verify    # also asks the registry
spaicely domains register bakkerijjansen.nl           # shows the price and asks first
spaicely domains transfer bakkerijjansen.nl           # opens the browser; the transfer code never touches the terminal
spaicely domains connect bakkerijjansen.nl --site 12  # shows the records that come along, then the nameservers to set
spaicely domains status bakkerijjansen.nl             # where the connection stands

spaicely dns ls bakkerijjansen.nl
spaicely dns add bakkerijjansen.nl TXT @ "google-site-verification=..."
spaicely dns add bakkerijjansen.nl MX @ mail.example.com --priority 10
spaicely dns rm bakkerijjansen.nl 31631305            # the number from dns ls

The first registration asks for the registrant's details once: --holder-name, --organization, --email, --phone (with country code), --street, --postal-code, --city and --country. The domain is always registered in the name of your account.

Any tool, and scripts

spaicely tools                                              # every tool the server offers
spaicely call sites.files.list '{"site_id": 12, "prefix": "blog/"}'
spaicely call scripts.enable '{"site_id": 12, "kind": "contact", "name": "Contact"}'

# --json before any command gives machine-readable output
spaicely --json versions | jq '.live'

Exit codes: 0 done, 1 failed, 2 wrong use, 3 not signed in, 5 conflict while publishing. In Windows PowerShell, put the JSON for call in single quotes as well.

In CI

With SPAICELY_TOKEN set, the CLI sends that token instead of the stored sign-in. Make a key for CI in the dashboard under Connected AIs: for one account or one site, it can upload and publish (sites:read content:write sites:publish), works for a year and is shown once. Store it as the secret SPAICELY_TOKEN.

# .github/workflows/deploy.yml
- run: npx spaicely deploy --publish --yes
  env:
    SPAICELY_TOKEN: ${{ secrets.SPAICELY_TOKEN }}

All commands

spaicely help <command> shows every option of a command.

Regions: who may change what

A role can be limited to actions on paths (create, update, delete, with patterns such as blog/**) and, on a page, to marked regions. A region is a pair of HTML comments around a block:

<!-- spaicely:edit opening-hours -->
  <p>Monday to Friday 8:00 to 18:00</p>
<!-- /spaicely:edit -->

<!-- spaicely:append news -->
  <article>…</article>
<!-- /spaicely:append -->

In an edit region anything may change; in an append region only additions are allowed, so what is there stays. Names are lowercase letters, digits, - and _. Someone limited to regions may not change anything else on the page, the markers included. sites.files.list shows the regions of each page, and sites.region.update changes one region on top of the live version without sending the rest of the site.

When someone else published while a version was being made, publishing merges: files only this version changed come along, and a page both changed takes this version's regions, as long as the other version left those regions alone. Anything else is a conflict, reported per path; read the live version and make the change again.

Forms

A static site can still take messages and signups. scripts.enable adds a form that Spaicely handles on https://scripts.spaicely.com, one address for every site, and answers with the HTML to put in a page:

<form action="https://scripts.spaicely.com/f/k3v9q2x7m1c8b4n6r0td" method="post">
  <input type="text" name="_hp" tabindex="-1" autocomplete="off" aria-hidden="true" style="position:absolute;left:-9999px">
  <label>Name <input name="name" required></label>
  <label>Email <input type="email" name="email" required></label>
  <label>Message <textarea name="message" rows="6" required></textarea></label>
  <button type="submit">Send</button>
</form>

A contact form mails every message to one recipient, by default the person who set it up; any other address confirms once by mail before it gets anything. The mail comes from no-reply@spaicely.com with the name of the site as sender, and replying goes straight to the visitor. A signup form keeps a list with double opt-in: the visitor confirms by mail, and scripts.subscribers returns the confirmed addresses with an unsubscribe link for each.

Style the form with the site's own CSS and add fields as you like; every field whose name does not start with _ ends up in the mail. The empty _hp field catches bots. A form only accepts posts from the site's own connected domain. To stay on the page, post it with fetch and Accept: application/json; the answer is then {"ok": true} or an error code, see the HTTP API. Sessions and a shopping cart need no server: keep them in the browser with localStorage.

MCP tools

Account and approvals

Domains and DNS

People and handovers

Sites and files

Mail forwarding

Forms

Web shop

HTTP API

Most of Spaicely is reached over MCP, but a few things are plain HTTP: domain search without an account, the forms on customer sites, uploading a site as one archive, and the OAuth endpoints every MCP client uses. Some examples first; the full list follows.

Is a domain free?

No account and no key. Names go in the path, comma-separated; extensions are optional.

curl https://app.spaicely.com/api/domains/search/bakkerijjansen/nl,com

{
  "results": [
    {
      "domain": "bakkerijjansen.nl",
      "extension": "nl",
      "status": "likely_available",
      "checked_via": "dns",
      "reason": "dns_only",
      "register_url": "https://app.spaicely.com/domains/new?name=bakkerijjansen.nl"
    },
    …
  ],
  "verify_url": "https://app.spaicely.com/api/domains/verify/bakkerijjansen.nl,bakkerijjansen.com",
  "statuses": { … },
  "reasons": { … }
}

The quick check only asks DNS. For the names someone likes, follow verify_url: it asks the registry (at most 10 domains) and gives available or taken, and a price for premium names. /api/domains/extensions lists every extension with its price.

curl https://app.spaicely.com/api/domains/verify/bakkerijjansen.nl,bakkerijjansen.com
curl https://app.spaicely.com/api/domains/extensions

From JavaScript in a browser (CORS is open):

const answer = await fetch("https://app.spaicely.com/api/domains/search/bakkerijjansen/nl,com").then((r) => r.json());
const free = answer.results.filter((r) => r.status !== "taken").map((r) => r.domain);

Sending a form from JavaScript

A form made with scripts.enable works as plain HTML. To stay on the page, send it with fetch and ask for JSON:

form.addEventListener("submit", async (event) => {
  event.preventDefault();
  const response = await fetch(form.action, {
    method: "POST",
    headers: { Accept: "application/json" },
    body: new URLSearchParams(new FormData(form)),
  });
  const answer = await response.json();   // {"ok": true} or {"ok": false, "error": "rate_limited"}
  form.replaceWith(answer.ok ? "Thank you, we will get back to you." : "That did not work, please try again later.");
});

Only the site's own connected domain may post; from anywhere else, curl included, the answer is 403 origin_not_allowed.

Uploading a site in one go

sites.upload_url gives a one-time address, valid for ten minutes. Send the site as a tar.gz to it; the answer is the new version, which sites.publish then puts live.

tar -czf site.tar.gz -C _site .
curl -T site.tar.gz "https://app.spaicely.com/uploads/<token from sites.upload_url>"

Calling MCP without a client library

The server is stateless, so one POST is one call. The public server needs no sign-in:

curl https://mcp.spaicely.com/mcp/public \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc": "2.0", "id": 1, "method": "tools/call",
       "params": {"name": "domains.search", "arguments": {"names": ["bakkerijjansen"], "extensions": ["nl"]}}}'

The signed-in server at https://mcp.spaicely.com/mcp takes the same requests with Authorization: Bearer <access token>. Without one it answers 401 with a WWW-Authenticate header that points to the protected resource metadata, where an MCP client finds everything it needs to sign in:

1. Read /.well-known/oauth-protected-resource/mcp on mcp.spaicely.com, then /.well-known/oauth-authorization-server on app.spaicely.com.
2. Register with POST /oauth/register (dynamic client registration; public clients, no secret), or skip this step and pass the https URL of your client ID metadata document as client_id.
3. Send the person to /oauth/authorize with PKCE S256 and resource=https://mcp.spaicely.com/mcp; they choose the account, sites and scopes.
4. Swap the code at POST /oauth/token. An access token lasts an hour; the refresh token is replaced at every use and lapses after 30 days unused.

All endpoints

Scopes

Rights a client asks for; on the consent screen they are all ticked and the person unticks what the AI may not do. A purchase always needs a second, confirmed call.