Move a website with your agent
Move an existing website to Neleto so every text, image and link is editable in the page builder, with one prompt for your agent.
There are two ways to get an existing website into Neleto. Both work; they lead to different results.
| Import | Rebuild with your agent | |
|---|---|---|
| What comes over | Blog posts from a WordPress export file, and any page by its address | Every page, rebuilt as components |
| What you get | Pages arrive as plain HTML: one block of code per page | Every text, image, link and colour is editable in the page builder |
| Effort | Minutes | A few minutes per page for the agent; an afternoon for a small site |
| Use it when | You need the content in quickly, or you're moving blog posts | You want the site to work like a Neleto site from day one (recommended) |
With the import alone, you've changed the system, but you don't have its benefits yet: changing a headline on an imported page still means editing HTML. The way to benefit right away is to let your agent rebuild the site as components. This page gives you the prompt for it.
Blog posts are best moved with the WordPress import in any case. The prompts below take care of the pages.
Before you start
- A Neleto site. The free plan is enough to try it.
- Your agent connected to that site, see Connect your agent.
- Ideally, an agent that can open web pages (a browser tool). It reads the old site's real design and checks the result on the live page. Without one, it works from the HTML source.
- The address of the website you want to move.
- For large WordPress sites: access to the WordPress REST API (
/wp-json) or an application password, and an agent environment with a shell (for example Claude Code), because the run keeps its progress in a file. - For a project on your computer (an HTML folder, a Vite, Astro or Next.js project): an agent environment with a shell that can open the project folder and start it.
Which prompt?
- Up to about 30 pages: Prompt 1. It rebuilds the site page by page from the live design.
- WordPress with 100+ pages: Prompt 2. It works in phases, takes the content from WordPress itself and stops after the inventory so you can check the plan before anything is built.
- A project on your computer, not online yet: Prompt 3 together with Prompt 1. It reads pages and design from the project folder and uploads images and fonts from your disk.
How it works
- Copy the prompt and replace
<SOURCE_URL>with the address of the old site. - Paste it into a session of your connected agent.
- The agent finds all pages, reads the design and lists the section types the site uses (hero, text with image, card grid, FAQ …). A section that appears on several pages becomes one component, so you and your client learn it once.
- It builds the layout, the components and every page, carries over titles and meta descriptions, and sets up redirects for old addresses that change. Neleto checks every page as it is saved for broken links, alt texts and search and accessibility basics, and the agent fixes what it finds right away.
- It checks every page: all sections present, no broken images, no template errors, and position and size of every element measured against the old site at three screen widths (2 px tolerance), accessibility, and Lighthouse scores.
- It reports old and new addresses, redirects, and everything it needs from you, for example where form submissions should go or a brand colour that fails contrast.
Then review the pages in the admin, invite your client as an editor and connect the domain.
Prompt 1: small and medium sites
Replace <SOURCE_URL>, for example https://www.example.com, then paste the whole block.
Replicate <SOURCE_URL> 1:1 on our Neleto CMS as a fully component-driven site — every text,
image, link and color editable in the CMS, nothing hard-coded in templates. Build every page
reachable from nav, footer and in-page links. Verify everything yourself before reporting.
Pass `verbose:false` on EVERY create/update call (responses shrink to ids; halves token cost).
## Step 1 — Discover
- Try /sitemap.xml (or /sitemap_index.xml) first, then crawl nav + footer + in-page links.
- Produce a page table: old URL → new Neleto route (no trailing slash — Neleto strips it,
"/x/" serves at "/x"), page <title>, meta description, og:image, canonical, lang.
## Step 2 — Pull the REAL design (live site = truth, never an archive)
- With a browser tool (Claude in Chrome, built-in browser, Playwright): per page a full-page
screenshot + computed styles (font-family/-weight/-size, line-height, colors, backgrounds,
padding, radius, section heights, buttons) + section/DOM structure. Match exact values.
- Capture at 1440px, 768px AND 390px wide, plus every breakpoint in the source's media queries.
- Base styles (the usual cause of misalignment — they come from the theme, not the sections):
html/body font-size, line-height, color, margin; box-sizing; container max-width + side
padding per breakpoint; default margins of h1–h6, p, ul. Copy the source's reset as is.
- Page builders (Elementor, Divi, WPBakery): the layout also comes from builder CSS (global kit
CSS, per-page post-<id>.css, frontend.min.css). Port the rules the page actually uses (Chrome
DevTools Coverage or PurgeCSS against the rendered page) — never paste whole builder
stylesheets; they cost Lighthouse points.
- Fonts: for every font-family in use, find where it is loaded (Google Fonts <link>,
@font-face in theme CSS, Adobe/Typekit, Elementor/OMGF local copies). Note family,
weights, styles and the woff2 URLs.
- Bot protection (Cloudflare 403 on fetch): a real browser session usually passes.
- No browser: read HTML/CSS source directly. Real values, not visual approximation.
- Screenshots I attach override anything you fetch.
## Step 3 — Section inventory (before creating anything)
Compare ALL pages and list the distinct section TYPES (hero, text+image, card grid, CTA
band, FAQ, contact …). A section that repeats across pages with different content is ONE
component used many times — not one component per page. Show the inventory as a short
table (type → pages using it → editable fields) and continue.
## Step 4 — Build
### Engine rules (strict)
1. Inline helpers: parentheses + commas — `{{ render_elements(page.elements) }}`,
`{{ image_path(img, "w_800,f_webp") }}`.
2. Block helpers bind with `as` — `{{#if x as v}}…{{/if}}`, `{{#each list as item}}…{{/each}}`.
3. String literals double-quoted, also inside attributes: `src="{{ image_path(img, "w_800") }}"`.
4. Undefined symbol / wrong arity = hard compile error that blanks the page — guard nullables.
5. Never triple braces (engine panics).
6. `{{ }}` is HTML-escaped — structural HTML (`<br>`, bold, spans) goes in the template.
Exception: a `richtext` property renders raw (use it for long body copy).
Richtext values may only contain what the admin editor can edit: p, h1–h4, strong, em, u, s,
a, ul/ol/li, blockquote, br, img, and a `<span class>` around a word. Layout markup inside
richtext (wrapper divs, block spans as line breaks, grid classes) locks the field in the
editor — put it in the template. A headline with a highlighted word = text properties
(e.g. `title`, `titleHighlight`) rendered in the template, not a richtext blob.
7. `{{ properties.key }}`, `{{ relations.id }}`, `{{ render_elements(children) }}` — never bare `{{ key }}`.
### Architecture — layout + page split
Layout `style` IS injected into <head>, before all component styles. Layout `script`, page
`style` and page `script` are NOT. So:
- Layout `style`: the @font-face rules (see Fonts) and the source's reset/base styles from
Step 2, nothing else.
- ALL other CSS in one Global Styles component (`template:""`, whole stylesheet in `style`,
source order). Section components carry template + form only (`style:""`) — this avoids
cross-component specificity ties. If you do put CSS in a section component, scope it
(`.banner .banner-inner{…}`), never bare classes that collide with shared ones.
- Site-wide JS in one Site Scripts component, wrapped in `DOMContentLoaded`; null-check every
lookup that isn't on every page. `position:fixed` nodes created by PAGE-element JS must be
`document.body.appendChild()`-ed at runtime (a fixed nav in the layout is fine).
- Slot component: `template:"<div>{{ slot }}</div>"`, empty form, icon `tabler:layout-dashboard`
(built-in id 0 does not resolve).
- Layout (`layout_create`, ONE call): template `{{ render_elements(page.layout.elements) }}`,
`style` as above, elements in order Global Styles, Site Scripts, Nav, slot, Footer. Resend
template AND style on every `layout_update` or they blank.
- Page template: `{{ render_elements(page.elements) }}` — section elements only, `layoutId` set.
Never repeat Nav/Footer/styles/scripts in `page.elements`.
- Fallback only if `layout_create` errors: Nav, Global Styles, Site Scripts, Footer as page
elements on every page; @font-face + base styles at the top of Global Styles.
- Icons: Tabler strings with `tabler:` prefix (`tabler:photo`, `tabler:menu-2`).
### Form properties
One per client-editable value: camelCase `id`, `label:{en,de}`, `type`, `defaultValue` from the
source. Types: text, textarea, richtext, number, checkbox, select, relation, builder. Leave
structural classes, decorative SVG, aria-*, animation hooks hard-coded.
Values repeated across pages (phone, address, opening hours — per location if there are
several) are global strings, edited in one place (admin → Translations):
`translation_create {key:"location.leipzig.phone", language:"de", content:"…"}`, rendered with
`{{ translation("location.leipzig.phone") }}` — the key must be a string literal.
### Images — ingest by URL, never upload when a URL exists
Editable image = `file` relation + sibling alt text property:
`{ "id":"image","type":"relation","relationName":"file","multiple":false,"defaultValue":null }`
`{ "id":"imageAlt","type":"text","defaultValue":"…" }`
Render: `{{#if relations.image as file}}<img src="{{ image_path(file, "w_900,f_webp") }}" alt="{{ properties.imageAlt }}">{{/if}}`
- `f_` is FORMAT only (webp/jpeg/png/avif). Never `f_cover` (400). Crop with CSS `object-fit:cover`.
- On the element: `data.image = { "sourceUrl":"https://…", "path":"<site>/<name>.webp",
"title":"…", "status":"public" }` — always set `path` (else opaque `mcp-ingest/…`).
Works in page_create/page_update/layout_update, on children and multiple relations.
- `sourceUrl` must be reachable by the Neleto server. Re-ingesting a Neleto file needs
`?options=w_800,f_webp` on the serve URL (bare → 400).
- Only a local file with no URL → `file_upload_url {path}`, then
`curl --upload-file <file> "<uploadUrl>"` (needs a shell). No shell: `file_upload_multipart`
(stripped small webp, ~1.2 KB parts with sha256, all parallel).
### Fonts — self-host every font, never hotlink
- Ingest each woff2 once (Google Fonts too — hotlinking them is a GDPR problem in the EU):
`file_upload {sourceUrl, path:"<site>/fonts/<family>-<weight>.woff2", status:"public"}`.
For Google Fonts, take the woff2 URLs from the fonts.googleapis.com/css2 response.
- Reference it as `url("/files/user-upload/<site>/fonts/<file>.woff2")` — the path you
uploaded to. NOT the returned serveUrl (bare serveUrl → 400).
- One @font-face per weight/style with `font-display:swap`, in layout `style`.
- Never point @font-face at the old domain: browsers block cross-origin fonts and the old
site goes offline after the move. Adobe/Typekit kits only work on registered domains →
ASK ME (add the new domain to the kit, or a licensed replacement).
- Copy each font-family stack in full, fallbacks included.
### Repeating lists — builder (undocumented shape, copy exactly)
{ "id":"items","type":"builder","label":{"en":"Items","de":"Items"},"description":null,"hint":null,"required":null,
"defaultValue":[{"id":"r1","data":{"title":"…","body":"…"}}],
"items":[{"id":"row","type":"text","name":"row","label":{"en":"Row","de":"Zeile"},"icon":null,"items":[],
"data":"","defaultValue":"","property":{"type":"text","defaultValue":""},
"props":[{"id":"title","type":"text","label":{"en":"Title","de":"Titel"},"defaultValue":null,"description":null,"hint":null,"required":null},
{"id":"body","type":"textarea","label":{"en":"Body","de":"Text"},"defaultValue":null,"description":null,"hint":null,"required":null}]}]}
- exactly one row-template; fields in its `props`; its `data`/`defaultValue` MUST be "".
- read rows as `{{#each properties.items as item}}{{ item.data.title }}{{/each}}`.
- Rows needing their own image/markup → child component under a `canHaveChildren:true` parent.
### Elements & data
- Every element: `visible:true`, `tempId`, `componentId`, `data`, `children:[]`
(page_create needs no `pageId`; page_update does).
- First creation auto-seeds `data` from each property's `defaultValue` → only send what has no
default (image ingests) or differs per instance (content of a reused section!).
- LATER updates are replace-semantics: `data` is NOT merged, auto-seed does NOT re-run.
Sending `{}` or a partial object wipes the section. Always resend COMPLETE data, and every
element with `id` AND `tempId` — omitted elements are deleted.
- Never `page_get` a finished page (blows the token limit); use `*_list`, or
`page_get` with `componentDetail:"minimal"` if you must inspect.
### Build order
1. `component_list` / `layout_list` / `page_list` — reuse what exists.
2. Create ALL components from the Step-3 inventory in one or two parallel batches.
3. `layout_create` in one call.
4. One `page_create` per route (parallel where possible): `layoutId`, `renderMode:"dynamic"`,
`status:"public"`, `useTailwind:false`, all section elements with their content and inline
image ingests, plus the page title/meta description/og data from Step 1 in the page's SEO
fields (check the page_create schema for their names). No create-empty-then-update.
Every page_create/page_update returns `check`: fix its errors and warnings before moving
on. Issue with `field` → resend the element with that field fixed; without `field` → fix
the component template (`component_update`, then `page_check` the pages using it);
`scope:"layout"` → `layout_update`.
5. Redirects for every old URL whose shape changed (trailing slash, renamed paths, .html).
6. Verify (Step 5). Then flip pages to `renderMode:"prerendered"` and re-verify.
## Step 5 — Verify every page
First `page_check` every page (server-side, fast): 0 errors, every remaining warning explained
in the report. It covers title/description/og tags, h1 and heading levels, alt texts, link and
button text, form labels and internal links. Then the browser checks below for what it can't
see (layout, fonts, contrast).
Load each live page (base URL from `settings_get` → publicBaseUrl) and run once:
(() => { document.querySelectorAll('.reveal,[class*="reveal"]').forEach(e=>e.classList.add('in'));
const q=s=>document.querySelectorAll(s).length;
const imgs=[...document.querySelectorAll('img')].filter(i=>!i.closest('#nlto-widget'));
return { sections:{/* expected counts per section class */},
imgBroken: imgs.filter(i=>i.naturalWidth===0).length,
leftovers: document.body.innerHTML.includes('{{') || /could not resolve symbol/i.test(document.body.innerText),
title: document.title, h1: q('h1'), mains: q('main'), lang: document.documentElement.lang }; })();
Bar: each section once and in order, imgBroken 0, leftovers false, one h1, HTTP 200, then one
screenshot per width (1440, 768, 390) next to the source's. Then:
- Fonts + layout match: run this on the SOURCE and on the copy, at 1440px, 768px and 390px:
(async()=>{ await document.fonts.ready;
const els=[...document.querySelectorAll('header,nav,section,h1,h2,h3,p,li,button,a[class*="btn"],img,footer')]
.filter(e=>!e.closest('#nlto-widget')).slice(0,120);
return { w:innerWidth,
fonts:[...document.fonts].filter(f=>f.status==='loaded').map(f=>f.family+' '+f.weight),
boxes:els.map(e=>{const r=e.getBoundingClientRect(),s=getComputedStyle(e);
return [e.tagName,(e.textContent||'').trim().slice(0,30),Math.round(r.left),Math.round(r.top+scrollY),
Math.round(r.width),Math.round(r.height),s.fontFamily.split(',')[0],s.fontSize,s.textAlign]}) }; })();
Bar: every family the source loads is loaded on the copy; elements matched by text are within
2px in left, top, width and height, with the same fontSize and textAlign. "The page loads" is
not a match — fix layout style / Global Styles until the numbers are.
- axe-core on every page: 0 violations (lang, labelled inputs, heading order, one <main>,
unique landmark labels, AA contrast). If fixing contrast would change a brand color, ASK ME.
- Lighthouse on the home page and one page per section-heavy template: report
Performance / Accessibility / Best Practices / SEO next to the source site's scores.
Target: no category worse than the source.
## Step 6 — Report
Table per page: old URL → new URL, redirect (y/n), axe violations, notes. Lighthouse
before/after. Fonts: self-hosted (family + weights) or open (licence). Everything you had to
assume. Open items that need my input (forms, analytics IDs).
Prompt 2: large WordPress sites
Replace <SOURCE_URL> and <WORKDIR> (the folder for the progress file and scripts).
Paste this prompt and Prompt 1 below it: Prompt 2 reuses its building and
checking rules.
Migrate the WordPress site <SOURCE_URL> to our Neleto CMS. Work in phases and keep all state
in <WORKDIR>/manifest.json so any run can be resumed or repeated without duplicates.
Follow all engine, architecture, image, builder and data rules from the site-copy prompt
(pasted below this one) — they apply unchanged. Pass `verbose:false` on every create/update.
## Phase 1 — Inventory (read-only). STOP afterwards and report to me.
1. Detect the API: GET /wp-json/ . If blocked, fall back to /wp-sitemap.xml or Yoast's
/sitemap_index.xml plus per-page HTML.
2. Pull everything, paginated (per_page=100, follow X-WP-TotalPages):
/wp/v2/pages, /wp/v2/posts, /wp/v2/categories, /wp/v2/tags, /wp/v2/media,
custom post types from /wp/v2/types, menus (/wp/v2/menu-items or /wp-api-menus if present).
Keep per item: id, slug, link, parent, template, modified, title, content.rendered,
excerpt, featured_media, and SEO from `yoast_head_json` (title, description, canonical,
robots, og:image) or Rank Math equivalents.
3. Detect the stack from HTML/body classes and asset paths: theme, page builder (Elementor,
Divi, WPBakery, Gutenberg), multilingual (WPML/Polylang → hreflang), forms (CF7, Gravity,
WPForms), shop (WooCommerce), search, comments, sliders, embedded maps/videos, tracking.
4. Cluster pages into TEMPLATES by WP template + section structure (screenshot 1–2
representatives each). Typical: home, standard content page, service/product detail,
team, contact, landing page, blog index, blog post, category archive, legal.
5. Write manifest.json: one row per URL with type, template cluster, SEO fields, image
URLs, word count, status:"pending", neletoId:null, newRoute (no trailing slash).
6. Report to me and WAIT:
- counts per type/template, languages, total media
- proposed component library (section types → fields) and content model
(what becomes a page, what goes into a Neleto content type/collection e.g. blog)
- plugin functionality that has NO 1:1 Neleto equivalent and needs a decision
(forms, shop, member areas, search, comments, events)
- dead weight to drop (drafts, orphan pages, empty tags, attachment pages, old landing pages)
- SEO risks and the redirect patterns you'll need
## Phase 2 — Template pilot (after my OK)
Build layout + component library + ONE representative page per template, with the
site-copy rules (layout/page split, Global Styles, one component per section TYPE, builder for lists,
images via sourceUrl with path "<site>/<yyyy>/<mm>/<file>"). Design from the live site's
computed styles, base styles and fonts (site-copy Step 2). Verify each pilot page (site-copy
Step 5: audit script, fonts + alignment check, axe 0, screenshots vs. source, Lighthouse). Write a `template-map` into the manifest: for each template, which
component receives which WP field. Report pilot URLs to me before bulk.
## Phase 3 — Bulk content (batches, resumable)
- Process manifest rows with status "pending" in batches of 10–20. For each: transform
WP content into the element data of its template, then ONE page_create (or page_update if
neletoId exists — then resend COMPLETE data + id + tempId; data is replace-semantics).
Write neletoId + status:"built" back to the manifest after each page.
- If you have a shell and API access to the Neleto MCP endpoint, do the transform and the
calls as a script (deterministic, no LLM retyping of content); the model only handles
rows the script flags.
- Content cleanup: strip page-builder wrappers and shortcodes ([vc_row], [et_pb_*],
elementor data attributes), keep semantic HTML (h2–h4, p, ul/ol, a, strong/em, table,
blockquote) in a `richtext` body; flag any unknown shortcode instead of dropping it.
- Links: rewrite internal absolute URLs to relative Neleto routes WITHOUT trailing slash;
resolve ?p= / ?page_id= links via the manifest; flag links to removed pages.
- Images: sourceUrl = original from /wp-content/uploads (not the -300x200 size variants),
explicit path, alt from WP media alt_text; dedupe by URL so each file is ingested once.
- SEO: carry title, meta description, canonical, robots/noindex and og:image into the
page's SEO fields; hreflang for language variants.
- Posts: into the Neleto blog/content type if the instance has one (check the tool list),
keeping date, author, categories, featured image; otherwise a post template page.
## Phase 4 — Redirects, verification, report
- Redirects: every old URL whose shape changes → 301 to its new route. Cover patterns:
trailing slash, /category/…, /tag/…, /author/…, date archives, /feed, attachment pages,
?p=/?page_id=, /wp-content/uploads/… for important PDFs, removed pages → nearest parent.
- `page_check` over ALL built pages: 0 errors (covers title + meta description, one h1,
alt texts, link text, form labels and every internal link). Plus, by script or batched
audit: HTTP 200, no "{{" or "could not resolve symbol", imgBroken 0, word count within ±10%
of the WP source.
- Layout match over ALL built pages, not just the pilots: the site-copy Step 5 fonts + layout
script on the WP URL and the Neleto URL at 1440, 768 and 390 px, same 2px bar. List every
page that misses it; most misses come from missing theme or page-builder CSS.
- axe-core 0 violations on every template pilot + a random 10% sample; Lighthouse per template
vs. the WordPress original (no category worse).
- Old sitemap: request every old URL against the new site → 200 or 301, never 404.
- Flip verified pages to renderMode:"prerendered".
- Report: counts built/skipped/flagged, redirect list, URLs with issues, open decisions.
Prompt 3: local project
For a site that isn't online yet, for example a folder of HTML files or a Vite, Astro
or Next.js project. Replace <PROJECT_DIR> with the project folder. Paste this prompt
and Prompt 1 below it: Prompt 3 only replaces how the agent finds pages, design
and files.
Replicate the local project in <PROJECT_DIR> on our Neleto CMS. Follow the site-copy prompt
(pasted below this one) with the changes below — everything else applies unchanged.
## Instead of Step 1 — Discover
- Routes from the project itself: file tree (pages/, app/, src/pages/, *.html) or the router
config. Ignore build output, node_modules and tests.
- Same page table as in Step 1; take title and meta from the source files or the rendered page.
## Instead of Step 2 — Design
- The project's CSS/SCSS and theme/Tailwind config are the truth. Start the dev server (or
open the build output) in the browser and collect computed styles, base styles, fonts and
screenshots at 1440 + 390 px from it, exactly as in Step 2.
- Tailwind projects: keep `useTailwind:false`. Run the project's build and put the generated
CSS into Global Styles (base/reset part into layout `style`), so the classes in your
templates keep working.
- Fonts usually sit in the project (public/, assets/fonts/) or in a package (@fontsource/…):
use those woff2 files.
## Assets (images, fonts, PDFs)
- The Neleto server cannot reach localhost or this disk: `sourceUrl` does not work for local
files. Per file: `file_upload_url {path:"<site>/…"}`, then
`curl --upload-file <local file> "<uploadUrl>"`. Use the returned id in element data, and
`/files/user-upload/<path>` for fonts. Never base64.
- Files that are also online (CDN, an old live site) can use `sourceUrl` as usual.
## Verify
- Step 5 as written, with the dev server as the source.
Tips from real migrations
- The section list comes first. Building page by page without it produces near-identical components that your client then has to learn twice.
- Fonts and spacing come from the theme, not the sections. If text sits a few pixels off or the font looks wrong, the theme's base styles, font files or the page builder's CSS (Elementor, Divi) are missing. The prompt has the agent copy them and measure every page against the original at three widths. Only the builder CSS a page actually uses gets ported, so Lighthouse doesn't drop.
- Keep it editable without AI. A headline with a highlighted word gets its own fields instead of HTML in a rich-text field, so editors can change it in the admin. Phone numbers and addresses that appear on many pages live in one place (Translations).
- Titles, descriptions and redirects matter as much as the look. A copy that looks perfect but drops them loses its search rankings, which people notice weeks later.
- Let the agent check accessibility. A 1:1 copy keeps the old site's accessibility problems; with the checks in the prompt, they get fixed during the move.
- Brand colours are your decision. If fixing contrast would change a brand colour, the agent asks you instead of deciding.
- Fixing content later: updates replace a section's content completely. Let the agent resend the full content of a section, not just the changed field.
Moving a client site for the first time? Talk to us: we do the first one with you.