[Public] Resend email verification code.
Connector
479,816 tools. Updated 2026-08-26 23:24
"resend" matching MCP tools:
- WORKFLOW: Step 2 of 4 - Continue infrastructure design conversation Send a user message to the active InsideOut session and receive the assistant reply. The response contains a clean message from Riley - display it to the user. ⚠️ CRITICAL: DO NOT answer Riley's questions yourself! Forward questions to the user and wait for their response. NEVER fabricate or assume the user's answer, even if you think you know what they would say. Examples of questions Riley asks that YOU MUST forward to the user: - 'Any questions or tweaks to these details?' - 'Ready for the cost estimate?' - 'Do you want to change the stack/config?' - 'Ready to proceed to Terraform?' When Riley asks ANY question, STOP and wait for the user's answer! 📋 WORKFLOW PHASES: The typical flow is conversation → tfgenerate → tfdeploy When terraform_ready=true appears in THIS tool's response, THEN you can call tfgenerate. ⚠️ DO NOT call tfgenerate until this tool returns! Wait for the response first. 🎯 KEY SIGNALS IN RESPONSE: - `[TERRAFORM_READY: true]` → NOW you can call tfgenerate - `[[BUTTON_TF_APPLY: ...]]` → Deployment is ready! Ask user if they want to deploy, then use tfdeploy - `[[BUTTON_TF_DESTROY: ...]]` → User confirmed destroy intent! Ask user to confirm, then use tfdestroy - `[[BUTTON_TF_PLAN: ...]]` → User wants to preview changes! Use tfplan to run a plan, then tfdeploy with plan_id to apply REQUIRES: session_id from convoopen response (format: sess_v2_...). OPTIONAL: timeout (integer) - seconds to wait for response. For Cursor, use 50 (default). Max 55. OPTIONAL: project_context (string) - Only pass genuinely NEW project details the user shares after convoopen. Do NOT resend context already provided in convoopen — Riley remembers it. Do NOT scan files or directories to gather this — only use what the user explicitly tells you. Example: user reveals a new constraint like 'we also need HIPAA compliance' mid-conversation. 💡 TIP: Use convostatus to check progress anytime. Examine workflow.usage prompt for more guidance.Connector
- WORKFLOW: Step 2 of 4 - Continue infrastructure design conversation Send a user message to the active InsideOut session and receive the assistant reply. The response contains a clean message from Riley - display it to the user. ⚠️ CRITICAL: DO NOT answer Riley's questions yourself! Forward questions to the user and wait for their response. NEVER fabricate or assume the user's answer, even if you think you know what they would say. Examples of questions Riley asks that YOU MUST forward to the user: - 'Any questions or tweaks to these details?' - 'Ready for the cost estimate?' - 'Do you want to change the stack/config?' - 'Ready to proceed to Terraform?' When Riley asks ANY question, STOP and wait for the user's answer! 📋 WORKFLOW PHASES: The typical flow is conversation → tfgenerate → tfdeploy When terraform_ready=true appears in THIS tool's response, THEN you can call tfgenerate. ⚠️ DO NOT call tfgenerate until this tool returns! Wait for the response first. 🎯 KEY SIGNALS IN RESPONSE: - `[TERRAFORM_READY: true]` → NOW you can call tfgenerate - `[[BUTTON_TF_APPLY: ...]]` → Deployment is ready! Ask user if they want to deploy, then use tfdeploy - `[[BUTTON_TF_DESTROY: ...]]` → User confirmed destroy intent! Ask user to confirm, then use tfdestroy - `[[BUTTON_TF_PLAN: ...]]` → User wants to preview changes! Use tfplan to run a plan, then tfdeploy with plan_id to apply REQUIRES: session_id from convoopen response (format: sess_v2_...). OPTIONAL: timeout (integer) - seconds to wait for response. For Cursor, use 50 (default). Max 55. OPTIONAL: project_context (string) - Only pass genuinely NEW project details the user shares after convoopen. Do NOT resend context already provided in convoopen — Riley remembers it. Do NOT scan files or directories to gather this — only use what the user explicitly tells you. Example: user reveals a new constraint like 'we also need HIPAA compliance' mid-conversation. 💡 TIP: Use convostatus to check progress anytime. Examine workflow.usage prompt for more guidance.Connector
- Confirma o numero do dono com o codigo OTP de 6 digitos que chegou no WhatsApp dele apos o `provision`. OBRIGATORIO antes de enviar/agendar: ate verificar, `send`/`reply`/`schedule` retornam 403 owner_not_verified. Se o codigo expirou ou errou demais, chame de novo apos pedir um novo (resend) ao operador.Connector
- Deploy a v2 app: an HTML document plus a capability manifest, hosted at its own URL. A redeploy only needs the content that changed. Every content field is optional when `app_id` is given, and an omitted one keeps what is live: omit `manifest` for an HTML-only change, omit `html` for a manifest-only change, omit `assets` to keep the current files. This is the cheap path and the default, because an omitted field costs no output tokens at all: a one-line colour change does not resend the whole document, and a manifest edit does not resend it either. A field only needs sending when its content differs from what is live. `assets: []` is the explicit way to clear the asset set, and omitting all three is refused, since there would be nothing to change. The extension keys used most often: app metadata; collections, with per-collection write, update, read and delete role lists, where write gates creates and also gates updates unless an update list is declared; externalHosts, a fetch allowlist; cdn, to allow CDN scripts and styles; capabilities, for Permissions-Policy opt-ins; embeds, an iframe frame-src allowlist; notify, for email-on-row rules; webhooks, for signed HTTP POST on-row rules; and agentTasks, to queue work for an agent running on the owner's own machine, described as a prompt rather than as code. The manifest grammar is documented in the Homespun guide that get_skill returns. Pass no `app_id` to create, which mints a slug and URL and requires both `html` and `manifest`, or pass `app_id` to redeploy an existing app. Supply the HTML inline as `html`, or as `html_path`, an absolute path read on the MCP-server host, which is the relay for a hosted connector or the CLI host for a locally-run one, and not the remote agent's machine; it avoids retransmitting a large HTML file on every deploy, only a locally-run connector can read it, and inline `html` wins if both are given. `dry_run:true` (alias `check`) validates only: it runs the full manifest and asset validation, the redeploy compat gate and the schedule-timezone advisory, then returns { ok, warnings, compat?, breaks? } without creating a version or mutating anything, and it resolves omitted fields the same way a real deploy would, so it reports on exactly the deploy that would run. A redeploy is refused with manifest_incompatible_redeploy, unless force:true, when it would strand rows already written (dropping a collection, tightening a schema, flipping appendOnly), or when it would widen what the app's install screen discloses: a collection's read reaching further than the live manifest, a capability added, cdn turned on, or a host added to externalHosts, embeds or a webhook target. The break quotes the sentence a user would now be asked to approve. Taking access away never prompts: dropping a role, dropping a capability, host or webhook, turning cdn off, or adding update:[\"creator\"] to a write:[\"anyone\"] collection, all redeploy clean. A removed collection is detached rather than deleted. Images, fonts, audio, video and data files ship with the app in the same call via `assets[]`. Each is validated and stored app-scoped and served at its `path` on the app's own origin, so the HTML references it by a stable same-origin path such as `<img src=\"frames/000.jpg\">`; media and font paths support HTTP Range for seeking. A redeploy's assets replace the previous version's set when sent, carry over when omitted, and are cleared by `assets: []`. Returns { app_id, slug, url, version, visibility, created } on create, or { app_id, version, compat, breaks? } on redeploy.Connector
- Create a Keelen account (or start agent login) — emails a 6-digit code. UNAUTHENTICATED — the only tool besides verify_email that works before a bearer key is configured. `email` is where the code is sent. Flow: signup(email) -> the user reads the 6-digit code from their inbox -> verify_email(email, code) returns a reveal-once API key -> save it as this server's `Authorization: Bearer <api_key>` header in your MCP client config -> reconnect -> get_onboarding_status() to continue setup. The code expires in 15 minutes; call signup again to resend. Response is uniform whether or not the email already has an account (enumeration-safe), so signup doubles as agent LOGIN. Rate-limited per IP and per email. ASK THE USER for `email` in chat and WAIT for their answer before calling this. Do NOT infer it from your client profile, the logged-in account, git config, or any other ambient source; if you already hold a candidate, echo it back and get an explicit yes first. Because this call doubles as LOGIN, a guessed address signs the user in to whatever workspace owns it, and the rest of setup then mints an API key on, and creates a project in, an account they did not choose.Connector
Matching MCP Servers
- AlicenseAqualityCmaintenanceProvides access to the Resend API, enabling AI assistants to list and retrieve items with typed responses and error handling.9MIT
- AlicenseNot gradedqualityDmaintenanceEnables sending emails through the Resend service API. Provides a simple email sending tool that integrates with MCP-compatible clients.19MIT
Matching MCP Connectors
Send, track, and manage transactional emails at scale
Transactional email for AI agents: templates, domain verify, and sends.
- Upload or attach a user-supplied or externally-designed image (bring-your-own asset) to a post: the creator's own visual (a product shot, their actual work, a card designed elsewhere) instead of an AI-generated image (niche_render_image_card photo, paid) or a flat brand card. Free, with no image-generation spend. For a visual-product maker the real piece is the sale. Input modes, in order of preference: (1) `upload_ref`, the FAST path for an agent that built the asset itself and can run a shell: POST the raw file to `/asset/upload` (multipart/form-data, your bearer token) to get back an `upload_ref`, then pass it here. The bytes travel over HTTP and never round-trip through the model as base64, so it's effectively instant for a real graphic. (2) `image_url`, a fetchable https URL (the server fetches + stores it; for an asset that already lives on the web). (3) `image: {mime_type, data_base64}`, inline base64, fine for small images only. (4) `image_chunk`, the no-shell FALLBACK: upload bounded chunks of base64. It still re-types the bytes through the model (slow), so use it only when the agent has no shell to curl with. Split the file's bytes into ~32-48KB pieces, base64 EACH independently, send in order, each with a `sha256` of that piece's raw bytes so the server catches a mis-transcribed chunk and has you resend just that one (this is what makes the slow path reliable). Omit upload_id on the first chunk; the response returns one to pass on the rest. Set `final:true` on the last chunk (optionally with `total_sha256`); that call assembles, validates, and attaches. The cell's output must already exist (use niche_add_output first if needed). Sets it as the post's image; publishes with the caption. A dimension_note warns if the image's aspect won't fit the cell. Undo-able (the prior image is kept in history).Connector
- Resend a hotel reservation confirmation email. Use either the confirmation number from a successful lookup_booking call, or the guest's full name and email address when they do not know their confirmation number, card last four, or check-in date. The email contains the hotel confirmation number the guest can then use with lookup_booking or cancel_booking. Recovery requests never reveal whether a reservation matched. The confirmation is sent only to the email address already on the booking record; there is no recipient override. Email changes are handled at https://stayker.com/service.Connector
- Create and activate a campaign on a lead list. You supply name, offer, leads[], sequence[] (per step: subject, body, delayDays), sendWindow, timezone, stopOnReply — the platform does not write copy. Steps schedule up front; suppressed leads are skipped. Returns { campaignId }. Campaigns send real mail, so a launch identical to one this account made in the last 60 seconds is REFUSED with 409 { code:'duplicate_campaign', existingCampaignId } rather than contacting the same prospects twice — check that campaign instead of relaunching. Resend the same idempotencyKey to retry a call whose response you lost: that replays the original result instead of being refused. Campaigns that differ in any field, and deliberate relaunches after the window, are never blocked.Connector
- Downgrade: release your N NEWEST live mailboxes now and lower the billed quantity. Inputs: count, acknowledged (must be true — this is a quoted, irreversible-this-cycle consent: the release is immediate for provisioning but there is NO mid-cycle credit; the lower price takes effect next renewal, minimum 5 mailboxes / $99). Returns { releasedCount, failedCount, unreleased, billing, deduplicated } where billing is the new projected monthly. `releasedCount` is what COMPLETED and can be less than the `count` you asked for; `failedCount` is how many the provider refused, which are STILL LIVE and still billed, and `unreleased` names those addresses — read them before concluding a downgrade landed. `deduplicated: true` means this call did NOT re-perform the downgrade — every count above describes an EARLIER call's already-recorded outcome under the same idempotencyKey, not new work done just now. This can be true even after the 30-day idempotency window itself has expired: the underlying release record persists independently, so a reused key still reports no re-release rather than silently starting a fresh one. `count` is RELATIVE — it releases that many MORE mailboxes, it does not set your fleet to that size — and release cannot be undone through this API, so ALWAYS pass an idempotencyKey: the FIRST call under a key resolves WHICH mailboxes to release and records that exact set, so every later call carrying the SAME key can only ever finish that same set. A same-key retry re-attempts the stragglers and can never release a mailbox outside them, whatever `count` you send with it (the recorded set wins over a changed count); a retry WITHOUT a key always releases another `count`. A genuine SECOND downgrade is therefore a NEW key — reusing an old one can only ever finish what that key already asked for. A call that came back with failedCount above zero did NOT finish, so its key is not frozen: resend the identical request with the same key until failedCount is 0 — from then on that key replays the finished result and releases nothing further. If a call returns 409 a release is already running for this account: wait, then re-read infrastructure_status before deciding whether to retry. To ADD mailboxes use setup_infrastructure / configure_byo_domain (request_managed_mailboxes).Connector
- Grade a sports bet against NegativeEV's game simulations. Input the bet as plain text (teams/players, market, line, odds); a multi-leg parlay in one string is graded leg by leg and priced as a whole. Use it when the caller has a SPECIFIC bet to evaluate — it prices a bet you name, it does not search for good bets, so there is nothing to send for 'what should I bet tonight'. Call `get_slate` first if it isn't known that today's games are simulated. Every result leads with `status`: `graded` (every leg scored — this is the only status that spends a check), `partial` (some legs scored), `ungraded` (the bet was understood but no leg is covered by the sims), `no_bet_found` (no bet recognized in the text), or `no_slate`, `unsupported_market`, `unsupported_sport`. When a leg doesn't score, `ungraded_legs[].reason` says why and `retry.rephrasing_helps` says whether re-wording could change the answer — it is false whenever the bet parsed, so do NOT resend the same bet in different words to work around an `ungraded` result. Covers MLB, WNBA, PGA, and ATP; any other sport returns unsupported_sport. Games that already started still grade, against the simulations from before first pitch (a pre-game projection, flagged as such).Connector
- Generate a complete multi-room house colour scheme from a single archive. Where the retrieved evidence supports it, rooms are grouped by documented provenance (same object, same pattern colourway, same source citation, same designer, same period+institution); where it does not, they are grouped by perceptual similarity and the response says so -- grouping_basis reports which, and provenance_credit reports how many delivered colours are individually evidenced versus documented as a GROUP (often zero). Every colour is a real archive record either way. Each room gets a full colour card set (dominant/secondary/joinery/textile/accent roles) with paint matches, LRV, illuminant behaviour, and WCAG data. A documentary grouping states exactly which documented fact ties its colours together (e.g. 'documented on the same Fitzwilliam Museum record for the Artichoke hanging, accession T.1-1979') and its weighted grouping_strength score -- historical claims are templated only from fields the archive record actually states; room/surface assignment is disclosed as editorial, never as historical fact. Orientation (north/south/east/west) is recorded as room context and surfaced in each room's light_context; in the current model it does not alter palette selection. Example: concept='Arts and Crafts movement family house', archive='ArtsAndCrafts', rooms=[{label:'Entrance Hall', room_type:'hallway', orientation:'north'}, {label:'Living Room', room_type:'living', orientation:'south'}]. Use interior_specify instead for a single room without cross-room grouping. The response includes house_ref -- pass that (not the full response) to palette_pdf's house_ref input to render the flagship document; the full response is often 60-100KB+, too large to safely resend as another tool call's input.Connector
- Create, update (edit), move/reschedule, shift, reflect, or manage a block's checklist — bulk/batch, one or many in a single call. Pass `ops`, an array where each item has an `op` (create | update | move | shift | reflect | checklist) plus that op's fields; a single edit is just a 1-item array. Times are 24-hour HH:MM; for an event crossing midnight set endNextDay=true. `reflect` records how a PAST planned event actually went (kept | skipped | changed | added, with an optional actual time) — it never renames or re-times the plan; target one occurrence of a recurring event by its `seriesId@YYYY-MM-DD` id. `checklist` manages a block's microtasks: pass `items` to set/replace the ordered list (a template edit — whole series, or one occurrence with scope 'this'), or `check`/`uncheck` (by item id or exact text) to tick them off for a single occurrence; the current microtasks + each one's done state come back on a get_schedule read as the event's `checklist`. For a recurring event choose a `scope`: 'all' (default), 'future', or 'this' (the last two need `occurrenceDate`). To re-time an existing event use `move` (new start/date, duration kept) or `shift` (relative nudge by `byMinutes`); use `update` only to also rename, re-kind, re-area, or resize (change `end`). If you know the duration but not a conflict-free time (or only a rough window), use `schedule` instead of a create. By default the whole batch is atomic: if ANY op fails validation (e.g. a conflict), nothing is written and the failing ops are returned as errors — fix and resend. Pass `partial: true` for best-effort (apply what's valid). Ops apply in order as one transaction and are checked against each other: two creates can't double-book a slot, and an earlier move frees a slot a later op can reuse. Target each event id at most once per batch. Reference an area/activity type by id or by `areaName`/`activityTypeName`; create new ones first with manage_categories. If the user has a Google Calendar connected, creating or editing a calendar-linked event (or one created under their default sync calendar) also pushes the change to Google — the same as editing on the dial; don't edit an event get_schedule/find_event marked `readOnly` (it's from a calendar the user doesn't own and the change would silently revert). To remove events or clear a day use delete_events. The response reports `applied`, `failed`, `skipped` (validated but not written because the atomic batch was rejected), and per-op `results` (each with its 0-based `index`).Connector
- Returns instructions for creating a DPF account, verifying its email, resending the verification code, or resetting a forgotten password — it never performs these itself and never asks for a password. A password typed into this chat would sit in the conversation transcript, so every action instead returns the DPF website's own form, or a curl command that reads the password from a shell variable the user sets themselves in their own terminal. Hand the command to the user to run — do not run it yourself even if you have shell access, since composing the export line would require seeing the password. action "register": requires email, firstName, lastName, and termsAccepted: true (only after the user has explicitly agreed to the DPF Terms of Service and Privacy Policy in this conversation). action "verify": confirm the 6-digit code DPF emailed after registration (requires otp). action "resend": re-send that code if it never arrived. action "forgot-password": request a password-reset code (requires email). action "reset-password": submit that code and set a new password (requires otp).Connector
- Relays a message you sealed locally with /svc/msg2-sdk.mjs (seal(mailbox, inner) → {ephemeralPubKey, viewTag, ct}). This tool cannot encrypt for you: sending plaintext here would expose it to the relay, so it only accepts the sealed triple. Replay-idempotent (a resend returns duplicate:true). The message appears in the public feed at releaseAt. If you cannot run the SDK, use v1 (POST /api/messages/send) and know that v1 is plaintext.Connector
- [chieflab_* alias of chiefmo_send_approved_email] Send an approved launch email through the email sending rail (current adapter: resend). USE WHEN the user has approved an email publishAction from chiefmo_launch_product and you need to fire the send. Strict approval gate (same shape as chiefmo_publish_approved_post). `from` MUST be on a domain verified at the adapter (resend.com) — check chieflab_list_email_senders first. Single recipient or short list (≤50). Money/external-system action — once sent cannot be unsent.Connector
- Use this when the signed-in user asks about pending parent invites, share codes, or whether their parent invite has been accepted yet. Returns each pending invite with hours_until_expiry. RULE: if any invite has hours_until_expiry < 24 (and not expired), proactively offer to resend it via the resend-parent-invite flow. If expired, offer to send a fresh invite. Requires sign-in.Connector
- USE WHEN any launch action carries a manualFallback brief — either because the channel has no automated provider at all (Product Hunt, Hacker News, Reddit, Discord, Slack, Indie Hackers, dev.to, YC Bookface, blog) OR because the channel HAS an automated provider but its connector isn't wired yet for this workspace (LinkedIn / X without a Zernio key; email without a Resend key + verified sender domain). Pattern: use the inline fallback NOW to ship the launch manually; connect the provider LATER (each fallback returns an upgradePath with the exact connector wiring) so the same action publishes automatically on the next launch. Returns: paste-ready title + body, per-channel checklist (best time, format, first-comment script), capture-URL-after instruction, measurement template for the 24h readback, and the optional upgradePath when automation is available. Converts a 'blocked' channel into a 5-minute human-in-the-loop ship. Approval-gated upstream: the originating publishAction must already be 'approved' on the reviewUrl before this tool returns the brief.Connector
- Validate an IBAN and identify the institution that holds the account. Performs format check, country-specific length check, and ISO 7064 mod-97 checksum verification. Also returns COUNTRY-level banking rules for the IBAN's country prefix (national currency, SEPA status, expected format). CROSS-CHECKS THE BENEFICIARY BANK. Where the country's IBAN registry mask defines the bank identifier as four alpha characters (GB, NL, IE, RO, PK, MT, JO, QA, KW and others), `bank_identifier.resolved_institution` names the institution that actually holds the account, read out of the IBAN itself. Call this whenever the user supplies an IBAN AND names a beneficiary bank or BIC — if the two disagree, that mismatch is a far better explanation for a rejected or returned payment than anything you can infer, and it is invisible without this call. `valid: true` means the check digits are right and NOTHING MORE — not that the account exists, is open, or belongs to the named beneficiary or the named bank. Never rule out the account details on the strength of it when diagnosing a failed payment (see `verification_note`). An IBAN encodes country + bank + account number and carries NO currency information. `country_currency` is the country's national currency, NOT this account's denomination — never infer a currency mismatch or a "resend in X" recommendation from it (see `currency_note` in the response). Examples: iban_validate("DE89370400440532013000") iban_validate("GB29 NWBK 6016 1331 9268 19")Connector
- Provision sending infrastructure: buy branded lookalike domains, create mailboxes, start warmup. New mailboxes are ramp-limited server-side — 5 sends/day in week 1, rising to 40/day after 4 weeks — and your own calls cannot exceed that cap; poll infrastructure_status for the current dailyCap. Inputs: brand, primaryDomain, domains + inboxesEach counts, persona, physicalAddress, senderIdentity. Billing is per-provisioned-mailbox ($10/mailbox + $49 platform, min 5) and the billed quantity follows what you provision here — pass quoteOnly:true first to preview the new count + projected monthly price before committing (no silent capacity addition). Every response carries a `billing` projection { provisionedAfter (the live count AFTER this call — reality, not the ask), projectedMonthlyCents, formula }: on quoteOnly it's the preview, on an actual provision it's the real post-provision bill (a capacity-limited partial reflects only what landed). Returns { jobId, billing } — `jobId` is a correlation id only, not a trackable job handle: there is no job store and no endpoint that accepts it, so do not poll for it or treat its presence as meaningful; it exists to correlate this response with logs. A `provisioning` field is present ONLY when the call returned still OWING work, and names which state: 'pending' (a domain's DNS registration is still completing — `pendingDomain` names one of them) or 'capacity_pending' (held at a spend/plan-slot limit, so polling will NOT progress until an operator raises it — call contact_operator instead of waiting). Its ABSENCE is what says the provision finished; the only way to find out is to re-call setup_infrastructure or read infrastructure_status's `nextSteps`. An outcome carrying `provisioning`, and a quoteOnly preview, are deliberately NOT recorded against your idempotencyKey — retrying with the same key re-runs the call and finishes the job rather than replaying the unfinished answer. `domains` and `inboxesEach` are the infrastructure you want to HAVE, not an amount to add: each call keeps and resumes what this account already has and buys only the shortfall, so to provision MORE you ask for a LARGER number (domains:2 after a call that provisioned one buys the second; raising inboxesEach tops each domain up). Repeating a call therefore never buys twice, whatever you do with idempotencyKey — resend it, change it, or omit it. The key controls response replay only and has no bearing on what is purchased, so a retry is always safe. A domain this account already registered but that never landed in your account (a prior call that failed after the purchase) is ADOPTED on the retry at zero extra cost rather than bought again. A domain whose DNS setup has not finished yet is recorded and never lost — there is no per-domain DNS field to poll (infrastructure_status reports a domain count, not per-domain detail), so read its `nextSteps` for what to do next, and repeat this same call to converge on the domain and finish its DNS setup. Slot semantics: `domains: N` covers ordinals 0..N-1, and each ordinal fills to its own mailbox count (uniform via `inboxesEach`, or per-ordinal via `distribution` — see below); a repeat call at the SAME `domains` provisions nothing new once every ordinal is satisfied, so reaching ordinal 1 needs `domains:2`, not a second `domains:1` call. Mailbox addresses are DETERMINISTIC — derived from `persona` + ordinal + slot — so keep `persona` EXACTLY as it was on a resume or retry; changing it mid-account does not move existing addresses but does change what a NEW ordinal derives. `distribution` (optional, alternative to `inboxesEach`) names the per-ordinal mailbox count directly — one entry per domain ordinal, e.g. `[3, 2]` for 3 mailboxes on domain 0 and 2 on domain 1 — for a shape `inboxesEach`'s single uniform number cannot express; supply exactly one of the two (an array with `domains` entries, or the uniform count). `registerDomains` is this tenant's opt-in consent to real domain purchases made on the platform's own account (our COGS — your bill is unchanged, mailbox-count-based only); only the operator's own global switch being armed too can ever actually enable it. OMITTING it leaves any consent you previously gave UNCHANGED — pass `false` explicitly to revoke it. A call that omits `registerDomains` (or sends it `false`) on a buy-bearing request (one that needs to purchase a new domain) is refused BEFORE any spend. Once this account has consented at least once, that refusal is a 400 `registrar_optin_missing`: 'registerDomains was not set on this request' — resend the identical call with it set to true to self-correct; this is never an operator escalation. (An account that has never consented, on a platform where domain registration is not yet enabled at all, instead sees the operator-facing 503 `registrar_unarmed` — indistinguishable from the outside except by status code, but the fix is the same: set `registerDomains: true` and retry.) Separately, a `registerDomains:true` call with NO `registrant` anywhere (neither in this request nor persisted from a prior one) fails with a 400 `incomplete_registrant` naming the missing fields — also before any purchase. Fresh candidates are de-duplicated against what this account already owns and checked for availability; if a call needs to buy a domain and no available un-owned candidate exists it fails with a 400 naming that, never a silent repeat purchase (a call that needs to buy nothing is unaffected). `registrant` (a full registrant-of-record object { firstName, lastName, email, phone, addressLine1, city, state, country, postalCode, organization (optional, defaults to brand) }) is OPTIONAL even when `registerDomains` is true whenever a complete registrant is already on file from a prior call — supplying one makes it authoritative for THIS call; omitting it re-uses the persisted one. This platform never invents a domain registrant's legal identity, so a call with no registrant anywhere (neither supplied nor persisted) is rejected naming the missing fields, at or before the actual purchase — never silently. There is NO background retry: a call returning `provisioning` needs the caller to retry it; the platform does not complete it for you on a timer. Every response carries `nextSteps` (see the discriminated `status`/`steps` shape) — the account's own next action, computed fresh each time, so a stalled setup is never silent.Connector