bind_section_to_collection
ChatGPTConnect a Uislice section on a page to a collection (datasource), so the section's items render entries from that collection instead of static placeholder content. This mirrors the "Datasource" panel in the Apollo editor. It is a separate operation from save_section_content / save_page_content / save_partial_content; those tools do NOT change a section's collection binding. Use it after inserting a list-style section (cards, grid, listing) that should show collection entries. Mechanics: looks up the section by sectionId (id or logicalId), validates that section.type === "Uislice", and applies a SET_COLLECTION operation: the binding lands on the page's draft under the revision lock, checked against the section's current anchor, and the draft is forked from the published head first when needed. Content (ctx) and config (cfg) are untouched. Errors: returns a clear error if the section is not found, the section is a Partial (binding partials is not supported here), the collection does not exist, or the section changed while the request was in flight (BASE_VERSION_MISMATCH: read the page again and retry).
create_collection
ChatGPTCreate a new content collection. A new collection starts with the built-in Name and Slug fields; call update_collection_schema to define the rest of the field schema (text/html/number/boolean/date/image/option/reference fields), keeping those two in the list. Setting hasPages=true auto-creates a per-entry page; false stores entries without pages.
create_entry
ChatGPTCreate a new entry in a collection
create_form
ChatGPTCreate a new form in a project. The form is on no page yet, so the live site does not change; a form section shows it by referencing its id (form.formId). For a scored form (quiz, scorecard, calculator), options carry points in their field's optionScores, keyed by option id: in score mode the points are summed and scoring.results shows the card whose scoreRange (inclusive, whole numbers) holds the total, scoring.gate before_results with gateFields asks for contact details before the result shows, calculator.display writes the total as a formatted amount such as $9.6M a year, calculator.stats adds up to 4 figures worked out from the total (such as a 3-year value or a payback time), and calculator.parts with each option's optionParts shows the visitor's own split of the total as bars. The schema is checked first: duplicate field names or option values, points keyed to options that do not exist, points in the wrong shape for resultType, and gateFields naming missing fields are refused; score range gaps and overlaps come back as warnings.
create_page
ChatGPTCreate a new page in a project
create_redirect
ChatGPTCreate a URL redirect
delete_entry
ChatGPTDelete a collection entry permanently
delete_page
ChatGPTDelete a page permanently
delete_redirect
ChatGPTDelete a URL redirect
duplicate_entry
ChatGPTDuplicate an existing collection entry with all its content
duplicate_page
ChatGPTDuplicate an existing page with all its sections and content
generate_image
ChatGPTGenerate image(s) with AI. Requires the project's AI image generation to be enabled (check get_project context.imageGeneration.enabled or get_imagegen_quota first); if generation is disabled, the monthly quota is exhausted, or too many jobs are running concurrently, the tool returns a clear error. START-ONLY: returns { status: 'pending', jobId } immediately; poll get_image_job(jobId) to retrieve the finished assets, then set an asset url as a section media.src. Use this for custom, branded, or illustrative imagery; prefer search_stock_images + upload_asset for real-world photos.
get_ai_referral_analytics
ChatGPTGet analytics for traffic referred from AI platforms (ChatGPT, Claude, Perplexity, etc.)
get_all_page_statuses
ChatGPTGet Google Search Console indexing status for all pages in a project
get_collection
ChatGPTGet a collection's schema and field definitions
get_entry
ChatGPTGet a collection entry's content and metadata
get_form
ChatGPTGet one form with its complete schema. Returns fields with their options, option points (optionScores), calculator part amounts (optionParts) and showWhen conditions, groups, scoring (result cards, score ranges, the email gate), calculator settings, delivery settings and updatedAt. Read here before update_form_schema and pass updatedAt as its expectedUpdatedAt.
get_form_submissions
ChatGPTGet submissions for a form
get_gsc_connection_status
ChatGPTCheck if Google Search Console is connected to this project
get_image_job
ChatGPTPoll an AI image-generation job started by generate_image. Returns { status, assets } where status is pending|running|completed|failed; when completed, assets is [{ id, url, description }] and each url is usable directly as a section media.src.
get_imagegen_quota
ChatGPTCheck the project's monthly AI image-generation quota before calling generate_image. Returns { used, limit, remaining, plan, unlimited } (remaining is null when unlimited).
get_page
ChatGPTGet details of a specific page
get_page_content
ChatGPTGet the actual text content of a page's sections (titles, descriptions, CTAs, images, items). Use this to read what's on the page before editing.
get_page_index_status
ChatGPTGet Google Search Console indexing status for a specific page
get_page_revisions
ChatGPTGet the revision history of a page to see previous versions
get_partial_content
ChatGPTGet the content of a partial (header, footer, or other reusable section)
get_project
ChatGPTGet details of a Pixelesq project
get_search_performance
ChatGPTGet Google Search Console search performance data (clicks, impressions, CTR, position)
get_section_content
ChatGPTGet a single section's full content and config from a page. Returns the complete section including all uislices with ctx (content) and cfg (layout config). Use this to inspect one section in isolation before editing, instead of loading the whole page. Typical flow: call get_page_content (or list_pages) to find the section id, then call get_section_content to read that one section, then call save_section_content to save your edits.
get_section_defaults
ChatGPTGet the full default content and config structure for a specific section type. Use this before creating a section to understand its exact data structure. Returns the complete defaults object with ctx (content) and cfg (layout config) that you can modify and pass to save_page_content. The defaults include properly structured fields. Replace the text values (title.value, desc.value, cta labels/urls, media src/alt, item content) with your generated content while keeping the structure intact.
get_site_analytics
ChatGPTGet site traffic analytics (pageviews, visits, bounce rate, duration)
get_theme
ChatGPTGet the current theme (colors, typography, spacing)
insert_section
ChatGPTInsert a brand-new section at a given position on a page. The MCP server loads the existing sections, splices the new one in, and saves. All existing sections are preserved. Use get_section_defaults first to get a valid section template for the type you want (e.g. HeroWithMedia, Faqs). Assign one fresh UUID and use it for both section.id and uislices[0].id (the server keys the section's row by the section id). Then call insert_section with position set to the zero-based index where the new section should appear, or -1 to append at the end. Set section.type to "Uislice" for a regular content section (or "Partial" for an embedded partial). The component name (HeroWithMedia, Faqs, etc) goes on uislices[0].type, not on section.type. When inserting a Partial (shared header/footer), use the partial's id as section.id and send props as {"ctx": {}, "cfg": {}} (both fields are required by the server; the partial's real content lives in its own revisions). You MUST provide lastVersion from get_page_content latestRevision.version.
inspect_url
ChatGPTInspect a URL in Google Search Console (indexing, crawl, robots.txt status)
list_assets
ChatGPTList media assets in a project (images, icons, SVGs)
list_collections
ChatGPTList all content collections in a project
list_domains
ChatGPTList custom domains for a project
list_entries
ChatGPTList entries in a collection
list_forms
ChatGPTList all forms in a project
list_pages
ChatGPTList all pages in a project
list_partials
ChatGPTList all partials (reusable sections like headers and footers) in a project
list_projects
ChatGPTList all your Pixelesq projects
list_redirects
ChatGPTList all URL redirects in a project
list_section_types
ChatGPTList available section types for building pages. Returns each type's name, description, group, use cases, content fields, and preview image URL. Groups: hero, features, content, faqs, testimonials, pricing, form, stats, logos, header, footer, cta, search, team. Use the optional group filter to narrow results.
publish_entry
ChatGPTPublish a collection entry to make it live
publish_page
ChatGPTPublish a page to make it live
publish_partial
ChatGPTPublish a partial (header, footer, or reusable section) to make it live across all pages
remove_section
ChatGPTRemove a section from a page by id. All other sections are preserved. The removal is an explicit DELETE_SECTION operation applied on the page's draft under the revision lock (the draft is forked from the published head first when needed). sectionId may be the section's id or its logicalId (both come from get_page_content; the logicalId survives a publish, the id does not). Pass the same idempotencyKey when retrying a call whose answer was lost, so the removal is applied once.
reorder_sections
ChatGPTReorder the sections on a page. Provide the full ordered list of section IDs (every existing section must be included exactly once). Content is preserved; only positions change.
revert_page_revision
ChatGPTRevert a page's draft to a previous revision. Creates a NEW draft revision whose content is copied from the given revision, making it the latest draft head. The given revision itself is not modified, and the published revision is unaffected until you publish. Use get_page_revisions to find the revision to revert to (e.g. the currently published revision). This is also the recovery path when the latest draft has become unreadable or corrupted: revert to the last known-good revision and continue from there.
revert_page_revision_to_version
ChatGPTRoll a page revision back to one of its numbered versions by deleting all newer version patches on that revision. Version numbers count up from 1 within a revision (each save adds one). Use this to undo recent saves on the current draft without creating a new revision. WARNING: deleted versions cannot be recovered. The revision's content rolls back to the state at the given version number.
save_entry_content
ChatGPTSave/update the content of a collection entry. Content should be a JSON object with keys matching the collection's field schema (use get_collection to see the schema). You MUST provide the lastVersion from the entry's latestRevision.version.
save_page_content
ChatGPTSave sections to a page. This replaces the page's content with the provided sections. Each section has: id (uuid), name, type (uislice component name), and uislices array. Each uislice has: id (uuid), type (same as section type), and props with ctx (content) and cfg (layout config). Common section types: HeroWithMedia, HeroWithMediaBelow, StickyFeatures, StickyFeaturesCard, HowItWorks, Faqs, FaqsOnCard, SimpleForm, PqPricing, CardWithMedia, TextGrid, LogoGrid, MediaBentoCards, TestimonialGrid. Content fields in ctx: title { value }, subtitle { value }, desc { value }, ctas [{ label, url, variant, color }], media [{ src, alt }], items [{ title { value }, desc { value }, ctas, media, icons }]. Config fields in cfg: section { bg, hSize, vSize }, grid { columns, gap }, textsBox { alignText }, mediaBox { widthMedia }, ctaBox { direction }. You MUST provide the lastVersion from the page's latestRevision.version.
save_partial_content
ChatGPTSave sections to a partial (header, footer, or other reusable section). This replaces the partial's content with the provided sections. Uses the same section structure as save_page_content. Unchanged fields (cfg and ctx) are automatically preserved from the existing content.
save_section_content
ChatGPTSave a single section on a page. The MCP server fetches the page's other sections from the server, slots your updated section in place (matched by section id), and saves the full result. Sibling sections are preserved automatically. Use this for any edit to one section. Start with get_section_content to read the section, modify the fields you want, then pass the (partial or full) section object back. Merge semantics (RFC 7396 JSON Merge Patch): - Fields you send override the server's values. - Fields you omit are preserved unchanged. - To explicitly clear a field, send it as null. - Arrays (ctas, items, media, icons, menu, social, legal) are REPLACED wholesale: send the full array you want, including any items you are keeping. To remove one item, send the array without it. To add one, send the array with it. section.type must be "Uislice" for regular content sections or "Partial" for embedded partials. The component name (HeroWithMedia, Faqs, etc) goes on uislices[0].type, not on section.type. LIMITATION: changing an existing section's COMPONENT type (uislices[0].type, e.g. Faqs -> FaqsOnCard) via this tool is silently ignored by the server. To change a component type, use remove_section followed by insert_section with the new type. Icons: a stored svgStr is drawn in place of pqIcon. On section and item icons, setting pqIcon drops the stored svgStr; on a button, menu or social icon send svgStr: null with the new pqIcon. You MUST provide lastVersion for optimistic concurrency: get_section_content returns it as lastVersion, get_page_content as latestRevision.version.
search_content
ChatGPTSearch across all content in a project (pages, entries, collections). Returns matching results with their type and metadata.
search_stock_images
ChatGPTSearch Unsplash for stock photos. Returns CANDIDATE image URLs only; to actually use one, import it with upload_asset(sourceUrl) so it is optimized and stored in the project's asset library, then set the returned url as a section media.src. Use this when you need a real-world photo and the user has not supplied one.
unbind_section_from_collection
ChatGPTDisconnect a Uislice section's collection binding so it no longer renders entries from a collection. Reverses bind_section_to_collection. Does not affect the section's content (ctx) or config (cfg). Applied as a SET_COLLECTION operation with no collection, on the page's draft under the revision lock, checked against the section's current anchor.
unpublish_page
ChatGPTUnpublish a page (take it offline)
unpublish_partial
ChatGPTUnpublish a partial (take it offline across all pages)
update_collection_schema
ChatGPTDefine or update the field schema of a collection. Pass the FULL ordered list of fields you want. This is a wholesale replace at the schema level (it is not a JSON Merge Patch). Each field has: - name: string identifier (used as the key in entry content) - label: human-readable label - type: one of name, slug, text, html, number, boolean, date, image, media, option, reference - required: optional boolean - helpText: optional help string - options: for option type, a comma-separated string of choices; for reference type, the target collection id; otherwise empty - list: optional boolean (allow array of values) - to: alternative for reference target id - config: optional flat object of type-specific settings. For date fields: { format, time, timeFormat } where format is one of "MMM D, YYYY" (default), "MMMM D, YYYY", "D MMM YYYY", "D MMMM YYYY", "MMM D", "MMMM D", "ddd, MMM D, YYYY", "dddd, MMMM D, YYYY", "MM/DD/YYYY", "DD/MM/YYYY", "DD.MM.YYYY", "YYYY-MM-DD", "MMM YYYY", "MMMM YYYY", "YYYY"; time is a boolean (false = calendar date only, true = date with time; this decides the value shape entries store); timeFormat is "12h" or "24h". A field sent without a config key keeps its stored config; config: null clears it. Other types take no config. Every collection has built-in Name and Slug fields (type name and type slug); they are required, never list, and their values are not part of content: the entry's name and URL slug live on the entry itself and change through update_entry. Keep both in the list when updating a collection that has them (a built-in cannot be removed or renamed); a collection holds at most one of each. A legacy collection whose name or slug is a plain text field can convert it by changing that field's type to the built-in one. Reserved field names: _raw, _pagination, _filters. The schema has no draft: live listings and entry pages read it as soon as it is saved. A field left out of the list is removed from the schema, and changing a date field's config, or removing or retyping a date field, republishes every published entry page of the collection.
update_entry
ChatGPTUpdate an existing collection entry
update_form_schema
ChatGPTChange a form's name or schema. Forms have no draft: when the form is on a published page, the change is live at once. Each top-level schema key you send (fields, groups, scoring, email and so on) replaces the stored one whole and keys you leave out are kept, so send complete values: the full fields array, the full scoring object. expectedUpdatedAt (updatedAt from get_form) is required, and the change is refused if the form changed since. The merged schema is checked like create_form's before anything is written: problems the change introduces are refused, ones already in the form come back as warnings, and fields the change removes are listed.
update_page_meta
ChatGPTUpdate a page's SEO metadata (title, description, OG image)
update_redirect
ChatGPTUpdate an existing URL redirect
update_theme
ChatGPTUpdate theme variables (colors, typography, spacing)
upload_asset
ChatGPTImport an image into the project's asset library, optimized. Provide EXACTLY ONE of sourceUrl (an http(s) URL the worker fetches, e.g. an Unsplash candidate) or base64Data (raw base64 image bytes, requires mimeType). Returns the stored asset { id, name, url, type, metadata }; use the returned url as a section media.src. Optimized images are stored as <name>.webp, so rely on the returned name/url, not the requested filename. There is no replace-in-place: to swap an image, upload a new one and repoint media.src.
upload_image
ChatGPTUse this when the user has a LOCAL image (pasted into the chat, or a file on their machine) that they want on a page. It opens an upload box in the chat where the user drops the image; it uploads straight to the project's media library and returns the asset URL, which you then set as a section media.src. Prefer this over upload_asset for user-supplied local images (a pasted image's bytes never reach you, so you cannot upload it yourself). For an image that already has a public URL, use upload_asset(sourceUrl) instead.
