Free16 abilities

Elementor (free)

These abilities ship in WPPilot Free and register on every install where the plugin is enabled.

At a glance

Elementor (free) registers 16 abilities: 6 that only read, 8 that write, and 2 marked destructive. That split is the practical answer to how much of this module can run unattended. Reads cost nothing and are safe to repeat, so discovery is the part to be generous with; the writes are where review belongs, and the destructive calls stop for an explicit confirmation every single time regardless of which profile is active.

Availability on your site

The Elementor (free) module ships in WPPilot Free, so it registers on every install where the plugin is active. No licence check and no dependency detection stand between the agent and these 16 abilities. What the connected agent can actually call is then narrowed twice more: by the safety profile active on the site, and by the WordPress capabilities of the user behind the credential. A read that succeeds for an administrator can be absent entirely for an editor.

Every write these abilities perform is recorded in the change ledger, and destructive calls can be routed through the approval queue so a person signs off before anything is applied. A successful tool result means the operation returned, not that the front end, the cache, and every dependent template are correct: that still needs a look.

Reads

Available in every safety profile, including Read Only. Inspection costs nothing and is not rate limited.

Ability	What it does
`wppilot/elementor-find-elements`Find Elementor Elements	Searches a document for elements matching a widget type, a settings value, or free text, and returns their ids with the path to each. This is how you act on "every button on the page" or "the heading that says Pricing" without reading the whole document: the answer is a short list of ids to pass to edit-element, move-element or delete-element. widget_type matches exactly (heading, button, e-heading). setting_key with setting_value matches elements whose setting equals that value. text matches any string value anywhere in an element's settings, case-insensitively, which is the one to reach for when you know what the page says but not how it is built.
`wppilot/elementor-get-page-settings`Get Elementor Page Settings	Returns a document's page settings — the editor's gear panel — together with the settings this particular document type accepts, read live from its own controls. Covers the page layout template (default, Elementor Canvas, Elementor Full Width), hide title, page background, page-level custom CSS, excerpt, featured image and comment status. Worth reading before deciding a layout problem lives in the element tree: a full-bleed hero inside a boxed page template is a page setting, not a container setting.
`wppilot/elementor-get-widget-params`Get Elementor Widget Params	Returns the settings of an Elementor widget that a build actually sets — the heading's text, link, tag and size — instead of the complete control list, which for one heading is 186 controls and around 22kb of motion effects, sticky rules, transform popovers, hover backgrounds and per-breakpoint duplicates. Use this before adding or editing a widget; reach for wppilot/elementor-get-schema when you need a control this view sets aside, such as a motion effect or a per-device override. Works on any registered widget, including ones an addon pack installed, because the rules read the live registry rather than a fixed catalog. The response says how many controls were set aside and why, so nothing disappears quietly.
`wppilot/elementor-check-setup`Check Elementor Setup	Reports the Elementor environment: core version, Pro version, whether the v4 atomic runtime is available (and its sub-features: style schema, global classes, variables, interactions), active kit values (container_width, container_padding, enabled breakpoints), and a list of detected configuration issues. Call this BEFORE a conversion so you know which features to rely on.
`wppilot/elementor-get-content`Get Elementor Content	Reads the Elementor document tree for a post. Output is COMPACT by default - a structural skeleton with only element ids, types, widget types, and children (no settings). The skeleton is small (typically a few hundred tokens) and is the right first call for tasks like "remake this page", "edit a widget", "understand the layout". After the skeleton, drill into the widget you care about with element_id:"<id>" - you get back that subtree (plus children) with full settings, cheaply. Do NOT pass full_dump:true unless you genuinely need every widget's settings at once (e.g. cloning the entire page verbatim or running a full audit); for every other use case it wastes thousands of tokens on data you will not use.
`wppilot/elementor-get-style-schema`Get Elementor v4 Style Schema	Returns the authoritative Elementor v4 atomic-widgets Style Schema - CSS property → prop-type descriptor. v4-ONLY: governs Global Classes, atomic widget base styles, and style variants. Does NOT apply to legacy v3 widgets (use wppilot/elementor-get-schema for those). Progressive disclosure: the full schema is ~35KB (60+ properties); prefer `overview:true` for a flat `{property: prop_kind}` discovery view, or `properties:["gap","padding",...]` to get detailed descriptors only for the props you plan to write. Per property, lists the prop kind (`size`, `color`, `string`, `number`, `union`, `dimensions`, `background`, `box-shadow`, …), the enum values when applicable, and for union / object props the nested alternatives.

Writes

Gated by the active profile and your WordPress capabilities. Rate limited to 120 per minute per credential.

Ability	What it does
`wppilot/elementor-add-element`Add Elementor Element	Inserts a new widget or container into an Elementor document, or grafts a pre-built subtree onto it. Use this instead of reading the whole document, editing the tree by hand and writing it back with wppilot/elementor-set-content: only the new element is described, ids are generated, and the rest of the page is untouched. Four shapes: element_type="widget" with widget_type (a v3 widget such as heading, or a v4 atomic one such as e-heading); element_type="container" for a v3 container; element_type="e-flexbox" or "e-div-block" for a v4 atomic container; or tree={...} to insert a whole prepared subtree, whose ids are regenerated so it can be inserted repeatedly without collisions. parent_id selects the container to insert into and defaults to the document root; position is a zero-based index among that parent's children and defaults to the end. element_id sets a semantic id, which is what per-element style classes are named after, so it is worth setting on anything you intend to style later. Validation runs server-side: an unknown control id or an invalid enum value aborts the insert and returns the compact schema of the affected widget inline, so a correction is one roundtrip away.
`wppilot/elementor-duplicate-element`Duplicate Elementor Element	Copies an element and everything under it, giving every node in the copy a fresh id, and inserts the copy into the document. By default it lands directly after the original, which is what "duplicate this section" normally means; pass parent_id and position to place it somewhere else. Regenerating the ids is the point of this ability: a copy that keeps them produces two elements answering to the same id, which is not reported as an error but makes per-element styles apply to both and lets the editor overwrite one of them on the next save.
`wppilot/elementor-move-element`Move Elementor Element	Moves an existing element to a different parent, a different position among its siblings, or both, keeping its id, settings, styles and children intact. Use this rather than deleting and re-adding: re-adding produces a new id, which breaks per-element styles named after it and any interaction that targets it. Omit parent_id to move to the document root; position is a zero-based index among the destination parent's children and appends when omitted. Moving a container into itself or into one of its own descendants is refused, because it would detach the branch and splice it back inside itself.
`wppilot/elementor-reorder-children`Reorder Elementor Children	Sets the order of a container's direct children in one call, by listing their ids in the order you want. Omit parent_id to reorder the document's top-level elements. The list must name exactly the children that container has — no additions, no omissions, no repeats — because a partial list is ambiguous about where the rest belong, and guessing would silently rearrange elements the caller never mentioned. Nothing is written unless the list matches.
`wppilot/elementor-set-page-settings`Set Elementor Page Settings	Writes page settings on an Elementor document, merged into what is stored so an unmentioned setting is left alone. Every key is validated against the settings that document type actually accepts — they differ between a page, a header and a popup — and an unknown one is refused with the valid names rather than saved into meta nothing reads. The most useful key is template: "elementor_canvas" strips the theme's header, footer and container entirely, "elementor_header_footer" keeps header and footer but drops the theme's content wrapper, "elementor_theme" hands the whole page to the theme's own template, and "default" leaves the theme in charge. Call wppilot/elementor-get-page-settings first to see what this document accepts.
`wppilot/elementor-clear-document-cache`Clear Elementor Document Cache	Clears Elementor Pro's rendered-element cache (the _elementor_element_cache post meta) for one or more documents, so the next front-end view rebuilds the HTML from the live element tree and dynamic content instead of serving stale cached output. Elementor checks this cache before applying render filters, so a template cached in one context can otherwise keep showing on other pages. Pass post_ids as the document ids to clear, including any nested template ids (each template caches independently of its parent). Use after editing a template or its dynamic bindings when a change is not appearing on the front end. Elementor rebuilds the cache on the next render, so this is non-destructive.
`wppilot/elementor-edit-element`Edit Elementor Element	Updates the settings of an existing element (widget or container) on an Elementor document. Settings are merged on top of existing settings by default - pass replace=true to overwrite the whole settings object. Validation runs server-side on every call: unknown control IDs or invalid enum values abort the write and return the compact content-only schema of the target element INLINE in the error, so you can correct and retry in a single roundtrip. wppilot/elementor-get-schema is an OPTIONAL discovery tool for unfamiliar widgets - it is NOT required before writing. Shape rules: use only keys present in the element's "controls" map; select/choose values MUST come from the control's "opts"; switchers use "rv" for on and "" for off; typography requires typography_typography="custom" first; dimensions are {unit,top,right,bottom,left,isLinked}; sliders are {size,unit}; colors are #RRGGBB; v3 controls carrying an "r" flag in the schema accept responsive overrides via the suffixed key `<key>_<breakpoint>` (e.g. typography_font_size_tablet, padding_mobile, _padding_widescreen) - `r:1` means every breakpoint is allowed, while `r:{min:<bp>}` / `r:{max:<bp>}` / `r:{min,max}` restrict the suffix to a closed window in the canonical size order (mobile < mobile_extra < tablet < tablet_extra < laptop < desktop < widescreen). Breakpoint names are the v4 ones listed in check-setup.kit.active_breakpoints and the same value shape applies to every variant; ATOMIC (v4) widgets accept ergonomic scalar values which the server auto-wraps into {"$$type": "<prop_key>", "value": <scalar>} - for both `settings` AND inside the `styles` map's `props` (e.g. color:"#FFFFFF", font-size:72, padding:{block-start:16,...}); or you can pass the wrapped shape directly; v4 atomic responsive uses the `styles` map's `variants[]` with `meta.breakpoint` (NOT suffixed keys); CONTENT FIELDS - single-line text controls (heading.title, button.text, icon-list[].text, image.caption, …) take plain text only; wysiwyg controls (text-editor.editor, testimonial.testimonial_content, …) take inline formatting only (`<strong>`, `<em>`, `<a>`, `<br>`); NEVER wrap content in inline-styled `<p style="…">…</p>` or other layout markup - alignment goes in `align`, font sizing/weight/family in `typography_*`, max-width in `_element_custom_width`, spacing in `_padding`/`_margin` (all responsive via the suffix shape above); the dedicated `html` widget IS the place for arbitrary HTML; do not emit controls whose "if" condition is not satisfied.
`wppilot/elementor-get-schema`Get Elementor Widget Schema	Discovery and exploration tool for Elementor widgets (v3 and v4) and the container element. Use this to understand what widgets exist, what controls they expose, and what enum values they accept. NOT required before writing - set-content / add-element / edit-element validate server-side on every call and return the compact schema of the affected widget INLINE in any error response. Two actions: "list" (discover) and "get" (describe). LIST without filters returns a minimal overview: {categories (alphabetically sorted list of category names - use these as "category" filter values), sources (map of package → widget count - use these as "source" filter values)}. No widget names are returned in the overview - drill into a subset with filters. LIST with any filter (name_contains, is_atomic, source, category - combined with AND) returns a flat widget list with {name, title, is_atomic, categories, source} per entry. For v4 atomic widgets use is_atomic:true. For keyword search use name_contains. GET takes widget_types (a list of strings, "__container__" allowed) and returns compact schemas {t, opts?, def?, rv?, if?, arr?, fields?} by default. For style checks, prefer include_styles:true with control_names:["padding","margin",...] or tab/section narrowing; broad include_styles:true on common v3 widgets can be very large. Use verbose:true only when labels / widget metadata are needed. The compact output shape is exactly what set-content / add-element / edit-element expect, so feed it back verbatim when you do use it.

Destructive

Marked destructive in the source, so each call needs an explicit confirmation flag, every time.

Ability What it does

wppilot/elementor-delete-elementDelete Elementor Element Deletes an element (widget or container) and all its children from an Elementor document. Permanent - there is no trash for Elementor elements.

wppilot/elementor-set-contentSet Elementor Content Writes a full Elementor document tree to a post, invalidates Elementor's internal CSS caches, and fires WordPress's clean_post_cache so third-party optimization plugins (Perfmatters, WP Rocket, LiteSpeed, etc.) that listen for post changes can purge their per-post caches and the frontend reflects the change immediately. Validation runs server-side on every call: unknown control IDs or invalid enum values abort the write (nothing is persisted) and return the compact content-only schemas of the affected widget types INLINE in the error, so you can correct and retry in a single roundtrip. wppilot/elementor-get-schema is an OPTIONAL discovery tool for learning what widgets exist and what their controls look like - it is NOT required before writing, validation is automatic. Shape rules: use only keys present in the widget's "controls" map; select/choose values MUST come from the control's "opts"; switchers use "rv" for on and "" for off; typography requires typography_typography="custom" first; dimensions are {unit,top,right,bottom,left,isLinked}; sliders are {size,unit}; colors are #RRGGBB; scalars for "arr: true" v3 controls are auto-wrapped into a one-element array; v3 controls carrying an "r" flag in the schema accept responsive overrides via the suffixed key <key>_<breakpoint> (e.g. typography_font_size_tablet, padding_mobile, _padding_widescreen) - r:1 means every breakpoint is allowed, while r:{min:<bp>} / r:{max:<bp>} / r:{min,max} restrict the suffix to a closed window in the canonical size order (mobile < mobile_extra < tablet < tablet_extra < laptop < desktop < widescreen). Breakpoint names are the v4 ones listed in check-setup.kit.active_breakpoints and the same value shape applies to every variant; ATOMIC (v4) widgets accept ergonomic scalar values which the server auto-wraps into {"$$type": "<prop_key>", "value": <scalar>} - for both settings AND inside the styles map's props (e.g. color:"#FFFFFF", font-size:72, padding:{block-start:16,...}); or you can pass the wrapped shape directly; v4 atomic responsive uses the styles map's variants[] with meta.breakpoint (NOT suffixed keys); CONTENT FIELDS - single-line text controls (heading.title, button.text, icon-list[].text, image.caption, …) take plain text only; wysiwyg controls (text-editor.editor, testimonial.testimonial_content, …) take inline formatting only (, , <a>,  ); NEVER wrap content in inline-styled … or other layout markup - alignment goes in align, font sizing/weight/family in typography_*, max-width in _element_custom_width, spacing in _padding/_margin (all responsive via the suffix shape above); the dedicated html widget IS the place for arbitrary HTML; do not emit controls whose "if" condition is not satisfied.

Ability	What it does
`wppilot/elementor-delete-element`Delete Elementor Element	Deletes an element (widget or container) and all its children from an Elementor document. Permanent - there is no trash for Elementor elements.
`wppilot/elementor-set-content`Set Elementor Content	Writes a full Elementor document tree to a post, invalidates Elementor's internal CSS caches, and fires WordPress's `clean_post_cache` so third-party optimization plugins (Perfmatters, WP Rocket, LiteSpeed, etc.) that listen for post changes can purge their per-post caches and the frontend reflects the change immediately. Validation runs server-side on every call: unknown control IDs or invalid enum values abort the write (nothing is persisted) and return the compact content-only schemas of the affected widget types INLINE in the error, so you can correct and retry in a single roundtrip. wppilot/elementor-get-schema is an OPTIONAL discovery tool for learning what widgets exist and what their controls look like - it is NOT required before writing, validation is automatic. Shape rules: use only keys present in the widget's "controls" map; select/choose values MUST come from the control's "opts"; switchers use "rv" for on and "" for off; typography requires typography_typography="custom" first; dimensions are {unit,top,right,bottom,left,isLinked}; sliders are {size,unit}; colors are #RRGGBB; scalars for "arr: true" v3 controls are auto-wrapped into a one-element array; v3 controls carrying an "r" flag in the schema accept responsive overrides via the suffixed key `<key>_<breakpoint>` (e.g. typography_font_size_tablet, padding_mobile, _padding_widescreen) - `r:1` means every breakpoint is allowed, while `r:{min:<bp>}` / `r:{max:<bp>}` / `r:{min,max}` restrict the suffix to a closed window in the canonical size order (mobile < mobile_extra < tablet < tablet_extra < laptop < desktop < widescreen). Breakpoint names are the v4 ones listed in check-setup.kit.active_breakpoints and the same value shape applies to every variant; ATOMIC (v4) widgets accept ergonomic scalar values which the server auto-wraps into {"$$type": "<prop_key>", "value": <scalar>} - for both `settings` AND inside the `styles` map's `props` (e.g. color:"#FFFFFF", font-size:72, padding:{block-start:16,...}); or you can pass the wrapped shape directly; v4 atomic responsive uses the `styles` map's `variants[]` with `meta.breakpoint` (NOT suffixed keys); CONTENT FIELDS - single-line text controls (heading.title, button.text, icon-list[].text, image.caption, …) take plain text only; wysiwyg controls (text-editor.editor, testimonial.testimonial_content, …) take inline formatting only (`<strong>`, `<em>`, `<a>`, `<br>`); NEVER wrap content in inline-styled `<p style="…">…</p>` or other layout markup - alignment goes in `align`, font sizing/weight/family in `typography_*`, max-width in `_element_custom_width`, spacing in `_padding`/`_margin` (all responsive via the suffix shape above); the dedicated `html` widget IS the place for arbitrary HTML; do not emit controls whose "if" condition is not satisfied.

PreviousElementor NextEtch