FormEdge

Duplicates an existing page as a new page that is never published. The whole draft (blocks, theme, custom CSS, the form placed on the page, the public title and description, and the custom domain settings) and the IP access rules are copied; the saved versions of the original are not. The name of the copy gets a suffix in the workspace language (" (copy)" for an English workspace). The copy shows the same form as the original; to collect responses separately, duplicate the form with duplicate_form, publish the copy with publish_form (requires the publish:forms scope; for a form delivered only through this page, set update_form standalone_public=false first), then point the formId of the form blocks at it with patch_page_draft — only a published (active) form can be placed on a page (an unpublished one returns 422). Returns 409 when the number of pages has reached the plan limit. Publish with publish_page (requires the publish:pages scope).

duplicate_page

Returns the form's submissions as CSV (filterable by period; subject to the plan's download limit). Availability depends on the workspace's current plan; a 403 with plan_upgrade_required=true means it is not available on the current plan (submissions and attachments can be viewed in the FormEdge dashboard). The source IP and User-Agent columns are empty by default; set include_source_metadata=true only when you need them (whether real values are written depends on the current plan). Forms that take payment also get payment columns (status, quantity, total amount written in the normal unit for the currency — currencies FormEdge does not know are left in the smallest currency unit, currency, paid at).

export_submissions_csv

Returns the workspace's branding settings (requires the read:tenant-settings scope). hide_powered_by is whether the "Powered by" badge in the footer is hidden, and hide_powered_by_allowed is whether the current plan allows hiding it. The badge setting is per workspace and applies at once to the footer of every page, every form and every completion screen (there is no per-page control). favicon_url is the workspace-wide favicon image URL (null = not set): it is used by every public page without its own favicon_url (set with patch_page_draft or update_page_draft) and always by the page assigned to the root of a public domain.

get_branding_settings

Returns a single form with its field definitions. fields can be passed to replace_form_fields as is. auto_reply in the response is the acknowledgement email sent to the respondent (enabled=false with the other members null means it is not configured); change it with update_form. acceptance in the response is the acceptance control (submission window, response limit and the notice shown while not accepting); all of its members being null means nothing is configured, and it is changed with update_form too. payment in the response is the payment collected after submitting (null when the form takes none): available (whether the settings allow payments to be accepted), unavailable_reason (why not, when available is false), currency, items ([{name, amount}]), total_amount for a quantity of 1, quantity ({field_key, max}: the answer to field_key becomes the quantity, null means always 1) and confirm_note. Amounts are integers in the smallest currency unit (1500 means JPY 1500; 500 means USD 5.00), the same unit update_form takes. Change it with update_form (payment). When available is false, unavailable_reason says what is missing: stripe_not_connected / stripe_not_ready (the user connects Stripe in the FormEdge dashboard), commerce_terms_missing (they enter the seller information there), plan_unavailable, suspended, or quantity_field_invalid / items_invalid (fixable with update_form). Tell the user which one it is. duplicate_check and screening in the response are the form-level duplicate check and AI screening settings (not in list_forms); change them with update_form.

get_form

Returns the workspace's language (locale) and time zone (timezone) (requires the read:tenant-settings scope). The settings are per workspace and determine the language of the notification emails sent to the workspace (submission notifications, invitations and the default wording of auto-reply emails) and the time zone used for submission timestamps in notification bodies and CSV exports, for the day boundaries of from/to date ranges, and for automatically named page versions (they are independent of the display language of public pages and forms). A value that is not configured is returned as null and falls back to its default (locale → ja, timezone → Asia/Tokyo); only one of the two may be unset. If anything is null, ask the user what they want and offer to set it with update_tenant_locale_settings (both values are required, so re-send the current value of the one that is already set). timezone is an IANA time zone name (e.g. Asia/Tokyo).

get_tenant_locale_settings

Returns the form's notification settings (webhook/slack/discord/teams/google_chat/line/email) (requires the read:notifications scope; contains sensitive data).

get_notification_settings

Returns a single page together with the draft being edited (blocks/theme/custom_css/title/meta_description/favicon_url/content_language/analytics_ga4_id). is_domain_root tells whether the page is currently assigned to the root URL of its public domain; such a page always uses the workspace-wide favicon (get_branding_settings) instead of its own favicon_url.

get_page

Returns the page's allowed IPs (whitelist), denied IPs (blacklist) and whether the current plan can use IP restrictions (plan_eligible). Entries are single IPv4 addresses or CIDR notation. An empty whitelist means no restriction (all allowed). IP restriction is a feature of the pro plan and above.

get_page_ip_rules

Returns the status of the workspace's public URL subdomain (slug) (requires the read:tenant-settings scope). The public URL is {slug}.{base_domain}. confirmed = whether it is confirmed, exposed = whether it has been exposed publicly, and used_changes/change_limit/remaining_changes = the change allowance (last 365 days), which is consumed only by changes to a slug that is both confirmed and exposed. change_limit depends on the workspace's current plan; when it is 0, a slug that is both confirmed and exposed cannot be changed. While base_domain is null, the slug host feature is disabled and update_tenant_slug returns 409.

get_tenant_slug

Returns a single submission in detail (answers, attachments, screening score). Availability depends on the workspace's current plan; a 403 with plan_upgrade_required=true means it is not available on the current plan (submissions and attachments can be viewed in the FormEdge dashboard). The source IP and User-Agent are not returned by default; set include_source_metadata=true only when you need them (whether real values are returned depends on the current plan). When the form takes payment, the response also carries payment: status (paid/unpaid), quantity, and amount (the total charged, i.e. unit price times quantity, as an integer in the smallest currency unit: 500 means USD 5.00) with its currency.

get_submission

Returns the workspace this connection belongs to and how much of each limit is in use. workspace = its name and public URL slug (slug is null while none is assigned). plan.code = the current plan code, and plan.trial_ends_at = the end of the time-limited trial (an ISO-8601 timestamp, null when the workspace is not in a trial). monthly_api_calls = API calls accepted this month (used/limit/remaining; resets_at = when the count starts over; stored data is not affected). forms and pages = the current count and the limit. fields_per_form.limit = the maximum number of fields in one form. monthly_submissions = submissions received this month and the limit. storage = bytes in use and the limit. A limit or remaining of -1 means unlimited. While the call count is temporarily unavailable, monthly_api_calls.used is null (and remaining is null too when there is a limit); null does not mean zero. Calling this tool is not counted in monthly_api_calls. Check the limits here before creating forms, pages or fields.

get_usage

Invites someone to the workspace by email (requires the write:members scope). An invitation email is sent to the address — the same email the FormEdge dashboard sends — and the recipient joins by opening the link and signing in with that address. The invitation is valid for 7 days, and the response is the created invitation (its id can be passed to cancel_invitation). role_code is member (can create and edit forms and pages) or admin (can additionally manage members and settings); it defaults to member, and owner cannot be granted by an invitation. Confirm the email address and the role with the user before running it, and tell them that an email will be sent. Returns 409 when that address already has a pending invitation that has not expired (cancel it first to re-send); an invitation that has already expired is replaced automatically, so it never blocks a re-invitation. It also returns 409 when the members plus pending invitations have reached the limit of the workspace's plan. Requires the API key or connection to belong to someone who is currently an owner or an admin (403 otherwise).

invite_member

Issues a signed upload URL (presigned PUT) for an image asset (requires the write:assets scope). This tool cannot send the file body itself: the client has to send the file to the upload_url in the response with an HTTP PUT that carries the Content-Type header, and the asset does not become usable until confirm_asset_upload is called after a successful PUT. If the client cannot make HTTP requests, upload the image in the FormEdge dashboard instead and use its URL from list_assets. Supported formats are PNG, JPEG, GIF and WebP.

create_asset_upload_url

Issues a time-limited preview URL that renders the draft being edited with the production renderer (re-issuing invalidates the previous URL, including the one shown in the admin app's preview modal and any URL already shared). Use it for the review step "the AI creates the draft → a human checks the preview URL → publish_page".

issue_page_preview_url

Returns the confirmed image assets (newest first, paginated, with their public URLs; requires the read:assets scope). The public_url of an existing asset can be used as is for a page's background or feature image.

list_assets

Returns the files attached to submissions (newest first, paginated). Availability depends on the workspace's current plan; a 403 with plan_upgrade_required=true means it is not available on the current plan (submissions and attachments can be viewed in the FormEdge dashboard).

list_attachments

Returns the custom domains (requires the read:custom-domains scope). The status of each item is pending (just registered, DNS not yet configured), verifying (verification in progress) or active (usable). The id of a domain that is active and disabled=false can be passed as custom_domain_id to update_form / update_page_draft to publish that page or form on it. root_page_id is the ID of the page currently assigned to the root URL (https://{hostname}/), or null when nothing is assigned. Change the assignment with use_as_domain_root on the page draft (patch_page_draft) followed by publish_page. A domain cannot be used for publishing on a plan with plan_eligible=false.

list_custom_domains

Returns the field types available for forms and their constraints (whether options are required, availability on this workspace's plan, the field_key format and the maximum number of fields). Always check it before create_form / replace_form_fields.

get_form_field_types

Returns the forms (newest first, with the submission count and the public URL). acceptance in each entry is the acceptance control (submission window, response limit and the notice shown while not accepting); all of its members being null means nothing is configured. payment_configured tells you whether the form takes a payment after the response is submitted; the amount and whether payments can be accepted are in get_form, and the settings are changed with update_form (payment).

list_forms

Returns the people who have joined the workspace (members) and the invitations that are still pending (invitations) (requires the read:members scope). role_code is owner, admin or member. The id of a pending invitation is what cancel_invitation takes. The two lists are paginated independently with the same page / per_page: members_pagination and invitations_pagination give the total of each, there is another page of a list when page * per_page < total, so check members_pagination and invitations_pagination separately (one can have more pages than the other). The invitation link itself is not returned; if an invitation email did not arrive, the member settings in the FormEdge dashboard can re-share the link. All member tools require the API key or connection to belong to someone who is currently an owner or an admin of the workspace; a credential whose owner is a plain member (or was demoted after it was issued) gets 403.

list_members

Returns the notification types available for notification settings and their constraints (availability on this workspace's plan, the per-type registration limit and the allowed values of content) (requires the read:notifications scope, which is not included in the default scopes). Always check it before update_notification_settings.

get_notification_types

Returns the page templates (template_key / name / tags). [Use include_capabilities: true before creating or editing] The canonical page authoring rules (the allowed block types, theme keys, fonts, value ranges, block_style_keys (the standard style vocabulary of a block), css_class_* (the rules for stable selectors used from custom_css) and anchor_id_* (the rules for the in-page link landing point) = capabilities) and the authoring guide authoring_notes (theme colors, how to use style, gradients, inline Markdown and other important rules) are returned only when include_capabilities is true. Always fetch them with true and follow them before assembling blocks or themes with create_page / update_page_draft / patch_page_draft (omitting it returns a light response with the template list only). Express the design with block.style and theme first, and limit custom_css to decorations that the standard vocabulary does not cover.

get_page_templates

Returns the page's saved versions (revisions) as metadata only (id, revision_number, label, created_at, published), newest first. retention_limit in the response is the maximum number of versions kept; saving a version while the number of versions has reached it may push out and delete an old version that falls outside the limit (the published version is protected, so it is not always deleted). Use the order of versions (newest first) and the published flag to judge whether a version would be pushed out. The content (blocks/theme) is not included. To inspect the content of a version, restore it into the draft with restore_page_version and then read it with get_page.

list_page_versions

Returns the pages (landing pages) ordered by last update, newest first.

list_pages

Returns the form's submissions in ascending order of submission time (oldest first, paginated, filterable by period). Availability depends on the workspace's current plan; a 403 with plan_upgrade_required=true means it is not available on the current plan (submissions and attachments can be viewed in the FormEdge dashboard). The source IP and User-Agent are not returned by default. Set include_source_metadata=true only when you need them (investigating abuse, detecting duplicates, access analysis); whether real values are returned depends on the current plan. When the form takes payment, each submission also carries payment: status (paid/unpaid), quantity, and amount (the total charged, i.e. unit price times quantity, as an integer in the smallest currency unit: 500 means USD 5.00) with its currency.

list_submissions

Publishes the form so that it can accept submissions (requires the publish:forms scope). form.public_url in the response is the public URL to share with respondents (it is null for a form with standalone_public=false, which is expected — it is delivered through a page). Returns 409 if the form is already published. Forms created with create_form already notify the workspace owner by email, so no warning is expected. If the response contains warnings, tell the user about them: a form published with no enabled notification destination (has_enabled_notification=false) notifies nobody of incoming submissions, so offer to set one up with update_notification_settings (requires write:notifications). For an embed-only form, run update_form standalone_public=false → publish_form → placing it on the page (the standalone public URL (/forms/{id}) is closed so there is no entry point, and publishing the page itself is a separate user action). Always set standalone_public=false first (publishing before closing it exposes the standalone URL for a moment).

publish_form

Takes a snapshot of the current draft and publishes the page (requires the publish:pages scope). Each publish replaces the published version and saves the current draft as a new version in the version history; when the history exceeds retention_limit, the oldest versions outside the limit are deleted (the published version is protected). Publishing the same draft again adds another version. A page whose public page title (title) is unset returns 422 (title is initialized from the name given to create_page, or set it with update_page_draft / patch_page_draft before publishing). public_url in the response is the public URL. Editing the draft after publishing does not change the published version until you publish again. If the draft carries a root assignment reservation (use_as_domain_root, set through patch_page_draft / update_page_draft), publishing applies and consumes it (true = assign this page to the root URL of the public domain; false = unassign it). Without a reservation, publishing a currently unpublished page (no published version on any domain) on the default domain (no custom domain selected) also assigns it to the root URL of the default domain automatically when no other page is published on the default domain and no other page holds that root assignment (typically the first page a workspace publishes). is_domain_root in the response is then true and public_url is the root URL: tell the user that this page is now their top page, and that use_as_domain_root=false followed by publish_page undoes it.

publish_page

Provisions or synchronizes the custom domain with Cloudflare and returns the latest verification state (requires the write:custom-domains scope). A manual trigger to call after the user has configured the DNS records shown by register_custom_domain, to confirm that the status has become active. Idempotent (the result does not change while the state is the same). Returns 404 for an unknown ID, and 422 with the reason in detail when the hostname cannot be registered (for example hostnames under example.com); report the reason to the user instead of retrying.

sync_custom_domain

Registers a custom domain (requires the write:custom-domains scope). Registration is provisioned asynchronously, and dns.records in the response holds the DNS records to configure (verification token, etc.). Right after registration the status is pending/verifying. The workflow has three steps: [1] register with this tool, [2] show dns.records to the user so they configure their DNS, [3] call sync_custom_domain afterwards to confirm activation (there is no polling or webhook). The number of registrations is capped at the plan limit (limit in list_custom_domains). Exceeding the limit or a duplicate hostname returns 409, a plan that does not support custom domains returns 403, and a hostname that cannot be registered returns 422 with the reason in detail (hostnames under example.com, example.net or example.org are not accepted; nothing is registered in that case). Ask the user for a domain they own instead of inventing one.

register_custom_domain

Changes only the label of a saved version (the content and the version number do not change). The response is the updated version list (metadata only).

update_page_version

Replaces all of the form's field definitions with the given array (an empty array deletes everything; display order follows the array order). Existing submission data is not affected. Validation violations are returned as 422 with errors; fix them and retry.

replace_form_fields

Replaces all of the form's notification settings with the given array (an empty array deletes everything; requires the write:notifications scope). Check the available types, plan availability and limits with get_notification_types (read:notifications). Violations are returned as 422 with errors.

update_notification_settings

Copies the content of the selected version over the draft (does not publish). [Caution] The current unsaved draft is overwritten and lost, so save it first with save_page_version if you want to keep it. Check the restored draft content with get_page, and publish it with publish_page. The response is the version list (metadata only).

restore_page_version

Discards the draft being edited and reverts it to the content of the currently published version (requires write:pages). The publish state does not change (nothing is published; only the draft reverts). The server identifies the published version. Returns 409 for an unpublished page (there is no published version). The discarded draft is lost, so save it first with save_page_version if you want to keep it. Reverting to the "last published version" of the past is not supported (only the currently published one).

revert_page_draft_to_published

Revokes the connection (OAuth grant) between this AI client and the FormEdge workspace. After it succeeds, every tool call returns 403 until the user approves the connection again on the approval page. Call it ONLY when the user explicitly asks to disconnect, to connect to a different workspace, or to change the permissions (scopes) the AI is allowed; never call it on your own judgement or to recover from an error. After calling it, ask the user to open connect_url from the response: on that page they can switch to another workspace ("Connect to a different workspace") or choose the scopes again, and tell them the tools cannot be used until the approval is finished. This revokes the connection rather than deleting it: it stays in Settings > External app connections in the FormEdge dashboard as revoked, where the user can delete it, and the next connection is never approved automatically - it always goes through the approval page (which is the point). No extra scope is required. Returns 403 when called with an API key (some clients other than ChatGPT connect with one; API keys are managed in the FormEdge dashboard). Calling it again on a connection that is already revoked also returns 403 with connect_url (the revoked connection no longer authenticates), so do not retry; 409 happens only in the rare race where the connection was revoked elsewhere at the same moment.

revoke_connection

Saves the page draft (name/blocks/theme, etc.) as a full replacement — use it only when rebuilding every block; for partial edits use patch_page_draft, which does not erase omitted fields. [Get page templates first] Assemble blocks/theme only after reading capabilities and authoring_notes from get_page_templates(include_capabilities: true), and follow them. [Propose saving a version before editing] Before changing the blocks/theme of an existing page, check the version count and retention_limit with list_page_versions, then snapshot the current state with save_page_version. Skip it when the page has no versions yet. Below retention_limit, save a version and say you did. At retention_limit the oldest version outside the limit may be pushed out and deleted (the published one is protected; judge from the order and the published flag), so in that case get the user's consent before saving. Without a version, a published page can still be reverted with revert_page_draft_to_published (an unpublished one cannot). [Validation] Violations return 422 with errors ([{field, message}]); fix and retry. warnings on success mean "saved but not rendered" — fix and save again. [Full replacement] Omitted fields are erased — notably custom_css and analytics_ga4_id (pass back the ones from get_page) and use_custom_domain (reverts to the default domain; use patch_page_draft to change only the publishing domain). title / meta_description / favicon_url / content_language are the exception: omitted = unchanged (an empty string clears them).

update_page_draft

Appends the current draft as a named snapshot (append-only). Old versions beyond the retention limit (retention_limit in list_page_versions) are pruned automatically (an old version outside the limit may be deleted; the published version is protected). Check the number of versions with list_page_versions first, and if it has reached retention_limit so that a version would be pushed out, get the user's consent before running it (no confirmation is needed below the limit). When label is omitted / null / empty or whitespace only, the version is named automatically with the date and time in the workspace time zone and language ("yyyy/MM/dd HH:mm" for ja, "MMM d, yyyy HH:mm" for en). This is not publishing (publish with publish_page). The response is the updated version list (metadata only).

save_page_version

Unpublishes a published form (stops accepting submissions; the definition and submission data are kept; requires publish:forms).

unpublish_form

Unpublishes a published page (the draft and past versions are kept; calling it on an unpublished page also succeeds idempotently; requires publish:pages).

unpublish_page

Updates the workspace's branding settings (requires the write:tenant-settings scope, and the API key or connection must belong to someone who is currently an owner or an admin of the workspace; 403 otherwise). hide_powered_by=true hides the "Powered by" badge in the footer (paid plans only; returns 403 when the plan does not allow it. Setting false to show it again is always allowed). The badge setting is per workspace, so it takes effect immediately on every published page and form at once. Do not use it for a request like "hide it on this page only" (tell the user that per-page control does not exist). favicon_url sets the workspace-wide favicon (null / omitted = unchanged; an empty string clears it; not plan-gated); for a single page use favicon_url of patch_page_draft (or update_page_draft) instead. hide_powered_by is required: pass the current value from get_branding_settings when changing only the favicon. Run it only on an explicit instruction from the user.

update_branding_settings