Gentic Landing Pages — Documentation

1. Getting Started

Sign Up & Get Your API Key

Before you can use Gentic Landing Pages, you need an API key to authenticate your requests.

1. Go to gentic.co/landing-pages and create an account.
2. Create an organization from your dashboard. API keys and billing are scoped to the organization.
3. Generate an API key and use it as a Bearer token in your MCP client.

2. Connecting to the MCP Server

The server is available at https://mcp.gentic.co/landing-pages. For Claude Code:

claude mcp add gentic-landing-pages \
  --transport http \
  https://mcp.gentic.co/landing-pages \
  --header "Authorization: Bearer YOUR_API_KEY"

For Claude Web and ChatGPT you can also connect via OAuth — no API key needed. See the connect section on the landing page for other MCP clients (n8n, OpenClaw).

3. Agent Skill

For the best results, pair the MCP server with the Gentic Landing Pages agent skill. The MCP server gives your agent tool access; the skill teaches it the optimal workflow order. Both the raw SKILL.md and a ready-to-upload .skill bundle are generated on demand from the live manifest, so they always reflect the current tools and pricing.

Add the skill directly via URL:

https://gentic.co/landing-pages/SKILL.md

Or upload a .skill bundle to Claude Managed Agents:

https://gentic.co/landing-pages/gentic-landing-pages.skill

Download this file and upload it wherever Claude Managed Agents asks for a .skill file. It's a zip bundle generated on demand from the latest SKILL.md.

4. When to Apply

• User wants to create a landing page, splash page, or coming-soon page.
• User wants the agent to generate the landing-page HTML from a brief (rather than pasting hand-written markup).
• User wants to deploy a page to a live URL without setting up hosting.
• User wants to clone or remix an existing web page as a landing page.
• User wants to collect email leads from a landing page.
• User wants to query or export leads collected from their pages.
• User wants to make small targeted edits to a live page (copy fixes, image swaps, color tweaks).
• User describes a change in prose — e.g. 'add a testimonial section after the hero', 'remove the pricing block' — rather than spelling out the exact strings to replace.
• User wants to fully rewrite or restructure a live landing page.
• User wants to see the version history of a deployed page, inspect a prior HTML revision, or roll back to a previous version.
• User wants brand colors, fonts, and voice applied consistently across all landing pages for an idea.
• User wants to extract a canonical brand guidelines document (colors, typography, voice, imagery, aesthetic) from a brand's public website, or look up a previously extracted record to inform page design.
• User wants to serve landing pages from their own custom domain (e.g. launch.acme.com) instead of a gentic.run subdomain.
• User wants to claim a brand subdomain under gentic.run (e.g. `pistash.gentic.run`) so different brands the user runs each get their own host.
• User wants to see which subdomains the org has already claimed, or release a brand subdomain that's no longer in use.

5. Workflow

1. 1. Pull brand guidelines from an existing site (optional)

   If the user already has a brand online (their own, or a reference), call `get_brand_guidelines` (free) with a `domain` or `url` to read an existing record. If nothing is stored, run `extract_brand_guidelines` (**$3/call, async — pass `webhook_url`**) to crawl key pages of the brand's public site, combine HTML/CSS parsing with vision-model analysis, and write a canonical document (colors, typography, voice, imagery, aesthetic direction, heritage, generative guardrails with source + confidence + evidence per field). Feed the returned colors/fonts/voice into `save_brand_style_guide` for an idea, or directly into the landing page HTML prompt.

2. 2. Set up a brand style guide with `save_brand_style_guide` (free, optional)

   Pass an `idea_slug` plus any subset of brand fields — `primary_color`, `secondary_color`, `accent_color`, `heading_font`, `body_font`, `voice`, `personality_traits`, `visual_mood`, `logo_direction`. Omitted fields keep their current value (if a guide already exists). Once saved, any landing page deployed (or replaced) with that `idea_slug` automatically gets the brand CSS injected. This is the same tool exposed by the Startup MCP — set the guide there while exploring the idea, then reuse it for every page.

3. 3. Fetch a reference page with `fetch_rendered_page` (10¢/call)

   Renders the target URL with full JavaScript execution and returns the complete DOM HTML. Use this when the user wants to clone or draw inspiration from an existing page. The rendered HTML can be passed directly to `deploy_landing_page` after modification. Unlike plain fetch, this captures SPAs, dynamic content, and JS-rendered layouts.

4. 4. Manage brand subdomains: `claim_subdomain`, `list_subdomains`, `release_subdomain` (free)

   Each org gets its original slug auto-claimed as its default subdomain (`{org-slug}.gentic.run`). Call `claim_subdomain` with a `subdomain` label (3-63 chars, lowercase alphanumeric + hyphens; reserved labels like `www`, `api`, `app`, `admin`, `mail`, `assets`, `static`, `cdn`, `mcp`, `auth`, `docs`, `blog`, `dashboard`, `console` are rejected) to reserve additional brand hosts under gentic.run — useful when one org runs multiple brands and wants each on its own subdomain. Subdomains are globally unique across orgs; collisions return a structured `taken` error so the agent can suggest a variant. Use `list_subdomains` to see everything the org owns (the entry with `is_default: true` is the auto-claimed org slug and cannot be released; each entry includes `created_at`). `release_subdomain` frees a label, but refuses if any active landing page is still pinned to it — delete or migrate those pages first.

5. 5. Generate HTML with `generate_landing_page` ($7.50/call, async)

   Pass a freeform `brief` describing the page — purpose, audience, sections, voice, calls-to-action — and Claude Opus 4.7 produces a complete, self-contained HTML document on a Modal worker. Returns immediately with a `job_id` and a `draft_id`. Polls aren't required; the user is emailed when the job completes (typically 1–5 minutes), and the draft can be inspected via `list_asset_jobs(type='landing_page')`. Optionally pass `idea_slug` (drives colors/fonts/tone from the saved brand style guide), `reference_url` (preferred — uses canonical brand guidelines and reproduces the original's structure when cloning), `base_html` (iterate on existing markup instead of regenerating), and `style_hints` (free-form overrides). $7.50 is charged **only when generation succeeds**. Promote the draft with `deploy_landing_page(draft_id=...)` (25¢) or `replace_landing_page(draft_id=...)` (25¢).

6. 6. Deploy with `deploy_landing_page` (25¢ from a draft, $7.50 from raw HTML)

   Provide a `slug` (lowercase, alphanumeric + hyphens, 3–64 chars) and a `title`. Then either pass `draft_id` from `generate_landing_page` (**preferred — 25¢**, the server fetches the draft HTML from S3 and promotes it live) or pass complete self-contained `html` directly (legacy raw-html path — $7.50). `draft_id` and `html` are mutually exclusive. Optionally pass `subdomain` to host the page under a specific brand host (must be claimed by your org). Subdomain precedence when omitted: (1) the idea's auto-claimed subdomain when `idea_slug` is provided and the idea has one, (2) the org's default subdomain. Pass `idea_slug` to inject the idea's brand style guide CSS, or `ignore_brand_style_guide: true` to skip. Also optional: `description` for metadata and `reference_url` for provenance. On the raw-html path, the document must be complete — inline all styles and scripts. The page goes live immediately at `{subdomain}.gentic.run/{slug}` and the response includes `subdomain` + `url` reflecting the actual host. Slug collisions are scoped per subdomain. Pass `on_conflict`: `"fail"` (default) throws a structured `slug_taken` error with `suggested_slug` + `existing_page_id`; `"suffix"` auto-appends `-2`, `-3`, … and returns `original_slug` + `slug_resolution: "suffix"`.

7. 7. Fetch current HTML with `get_landing_page_html` (free)

   Pass a `page_id` to read back the live HTML plus a `content_hash`. Always call this before `patch_landing_page` so your edits are authored against the current version — and pass the returned `content_hash` as `expected_content_hash` on the patch for optimistic concurrency (prevents clobbering edits from another agent).

8. 8. Apply small mechanical edits with `patch_landing_page` (50¢/call)

   Use this when **you can spell out the exact old/new strings** — copy fixes, image src swaps, color tweaks. Pass `page_id` and an `edits` array of `{ old_string, new_string, replace_all? }`. Each `old_string` must appear exactly once in the HTML (or set `replace_all: true`) — include enough surrounding context to make it unique. Pass `new_string: ""` to delete the matched substring. Edits apply sequentially; each sees the result of prior edits. Optionally pass `expected_content_hash` from `get_landing_page_html` for concurrency safety. For prose-described changes ("add a testimonial section after the hero"), reach for `edit_landing_page` ($1) instead — it has Gemini compute the diff for you.

9. 9. Describe edits in prose with `edit_landing_page` ($1/call)

   Use this when the user describes a change in natural language — "add a 3-card testimonial section after the hero", "remove the pricing block", "swap the CTA from 'Sign up' to 'Get early access' everywhere". Pass `page_id` and a freeform `brief`. The server fetches the live HTML, asks Gemini to compute minimal-diff string-replacement edits, and applies them. Cheaper than `replace_landing_page` (full Opus rewrite, 25¢ from a draft / $7.50 raw) and more capable than `patch_landing_page` (50¢, mechanical only). Optionally pass `expected_content_hash` from `get_landing_page_html` for concurrency safety. **Tier picker:** mechanical and you know the strings → `patch_landing_page` (50¢). Prose-described targeted change → `edit_landing_page` ($1). Layout overhaul or full rewrite → `replace_landing_page`.

10. 10. Full rewrites with `replace_landing_page` (25¢ from a draft, $7.50 from raw HTML)

    For layout changes, major restructures, or metadata-only updates, pass `page_id` plus either a `draft_id` from `generate_landing_page` (**preferred — 25¢**) or complete `html` (legacy — $7.50). `title` and `description` are optional. Omit both `draft_id` and `html` to update just metadata. Supports `idea_slug` and `ignore_brand_style_guide` for brand CSS injection. Reach for this only when `patch_landing_page` (50¢) won't cut it.

11. 11. Browse history with `list_landing_page_versions` and `get_landing_page_version` (free)

    Every `deploy`, `replace`, `patch`, and `restore` writes an immutable HTML version. Call `list_landing_page_versions` with a `page_id` to get every version's `version_id`, `created_at`, content hash, byte size, and `source` (`deploy` / `replace` / `patch` / `restore`). Call `get_landing_page_version` with `page_id` + `version_id` to fetch the historical HTML for inspection or diffing — useful before deciding what to roll back to.

12. 12. Roll back with `restore_landing_page_version` (25¢/call)

    Pass `page_id` + `version_id` (from `list_landing_page_versions`) to revert the page to that historical HTML. The restore writes a **new** immutable version (`source: "restore"`) pointing at the historical content and promotes it to the live URL — the prior current version stays in history, so a restore is itself reversible.

13. 13. Deprecated: `update_landing_page` ($7.50/call)

    An alias for `replace_landing_page`, kept temporarily for backwards compatibility. It will be removed in the next release — migrate agents and skills to call `replace_landing_page` (for rewrites) or `patch_landing_page` (for small edits) directly.

14. 14. List pages with `list_landing_pages` (free)

    Returns all pages for the organization with metadata, lead counts, and the `subdomain` each page is hosted on (so you can see at a glance which brand a page lives under). Pass `subdomain` to filter to a single brand host, or `include_deleted: true` to see soft-deleted pages. Use this to check what's currently deployed before creating new pages or to find page IDs for other operations.

15. 15. Query leads with `get_landing_page_leads` (free)

    Pass a `page_id` to retrieve collected email leads in reverse chronological order. Supports `limit` (default 100, max 500) and `offset` for pagination. Use this to review lead quality inline or to check submission volume.

16. 16. Export leads with `export_landing_page_leads` (free)

    Returns a signed CSV download URL that expires in **1 hour**. Pass `page_id` to export leads from a specific page, or omit it to export leads across all pages. Mention the 1-hour expiry to the user.

17. 17. Delete pages with `delete_landing_page` (free)

    Soft-deletes a page — removes it from public hosting but **preserves all lead data**. Leads remain queryable and exportable after deletion. Use this when a campaign ends or a page needs to be taken down.

18. 18. Connect a custom domain with `connect_custom_domain` (25¢/call)

    Serve pages from the customer's own domain (e.g. `launch.acme.com`) instead of a `{subdomain}.gentic.run` host. Pass the `domain` and the tool provisions a Let's Encrypt cert via Fly and returns the CNAME record the customer must add at their DNS provider. Once the CNAME propagates (usually a few minutes), call `verify_custom_domain` to finalize. Use `list_custom_domains` (free) at any point to see connected domains and their verification status, and `disconnect_custom_domain` (free) to remove a domain — it tears down the Fly cert and stops serving pages on it.

19. 19. Lead capture REST endpoint (not an MCP tool)

    Deployed pages can submit leads to `POST /api/leads/:orgSlug/:pageId` with a JSON body containing `email` (required) and optional `name`, `source`, and `metadata` fields. This endpoint is built into the hosting infrastructure — it's not called via MCP but should be referenced when building page HTML with forms.

6. Tool Reference

26 tools, rendered live from the Gentic MCP manifest. Parameter tables come directly from each tool's JSON Schema.

7. Pricing

Pricing is pulled live from the Gentic MCP manifest. All prices are per call and deducted from your Gentic credits.

8. Notes

• Pages are deployed to `{subdomain}.gentic.run/{page-slug}`. Every org's original slug is auto-claimed as its default subdomain; additional brand subdomains can be reserved with `claim_subdomain`. Deploy precedence when no `subdomain` is passed: explicit input → idea's auto-claimed subdomain (when `idea_slug` is provided) → org default. The `url` and `subdomain` fields on every deploy/list/replace/get response reflect the actual host — never reconstruct URLs from `org_slug + slug`.
• Slug uniqueness is **scoped per subdomain** — the same path slug (e.g. `/launch`) can exist on two different brand subdomains without collision.
• **Generate-then-promote is the cheapest path.** `generate_landing_page` ($7.50, async, charged only on success) writes an immutable draft via Claude Opus 4.7 and returns a `draft_id`. Promote with `deploy_landing_page(draft_id=...)` or `replace_landing_page(draft_id=...)` for **25¢**. Pass `html` directly only when you already have hand-written markup (legacy $7.50 path).
• On the raw-html path, HTML must be **complete and self-contained** — inline all CSS and JS. External resources may break or load slowly. Generated drafts are already self-contained.
• **Three tiers for editing a live page, by intent and cost.** `patch_landing_page` (50¢) — mechanical string replacement when you already know the exact old/new strings (typos, image swaps, color tweaks). `edit_landing_page` ($1) — describe the change in prose and Gemini computes the minimal diff ("add a testimonial section after the hero", "remove the pricing block"). `replace_landing_page` (25¢ from a draft, $7.50 raw) — layout changes and full rewrites only.
• Always call `get_landing_page_html` before `patch_landing_page` and pass the returned `content_hash` as `expected_content_hash` to avoid clobbering concurrent edits.
• **Every change is versioned.** `deploy`, `replace`, `patch`, and `restore` each write an immutable version row (with content hash, byte size, and `source`). Inspect history with `list_landing_page_versions` (free) and `get_landing_page_version` (free); roll back with `restore_landing_page_version` (25¢) — restores themselves are reversible because they create a new version rather than overwriting history.
• Pass `idea_slug` to `deploy_landing_page` or `replace_landing_page` to auto-inject brand CSS from a style guide saved via `save_brand_style_guide`. Set `ignore_brand_style_guide: true` to opt out.
• `update_landing_page` is **deprecated** — it's an alias for `replace_landing_page` and will be removed in the next release. Migrate now.
• Lead capture is built in. The REST endpoint `POST /api/leads/:orgSlug/:pageId` accepts `email` (required), `name`, `source`, and `metadata`.
• Soft-deleted pages preserve all lead data — leads remain queryable and exportable.
• Export CSV download links expire in **1 hour**.
• Slugs must be lowercase, alphanumeric with hyphens, 3–64 characters, and cannot start or end with a hyphen. Subdomain labels follow the same rules with a 63-char max and a reserved-words denylist (`www`, `api`, `app`, `admin`, `mail`, `assets`, `static`, `cdn`, `mcp`, `auth`, `docs`, `blog`, `dashboard`, `console`).
• Brand subdomains: use `claim_subdomain` to reserve a brand host (free), `list_subdomains` to see what's owned (the `is_default` entry is the auto-claimed org slug and cannot be released), and `release_subdomain` to free a label. `release_subdomain` refuses if any active landing page is still pinned to that subdomain — delete or migrate those pages first.
• Slug collisions on `deploy_landing_page`: if the user didn't pin a specific slug, pass `on_conflict: "suffix"` so the server auto-picks a free variant (`-2`, `-3`, …) and returns it as `slug_resolution: "suffix"` with the `original_slug`. Otherwise leave `on_conflict` as `"fail"` (default) and, on a `slug_taken` error (payload: `{ error: "slug_taken", suggested_slug, existing_page_id, message }`), either retry `deploy_landing_page` with `suggested_slug` or switch to `replace_landing_page` against `existing_page_id` — whichever matches user intent.
• Custom domains: after `connect_custom_domain`, the customer must add the returned CNAME record at their DNS provider. Call `verify_custom_domain` once DNS has propagated (usually a few minutes) to flip the mapping to verified and start serving pages on that domain.
• Brand guidelines: `extract_brand_guidelines` costs **$3/call** and is async — pass `webhook_url` to avoid blocking. The record is keyed by domain and org-scoped; re-reading via `get_brand_guidelines` is always free.
• All tools are organization-scoped — users only see their own pages, leads, and custom domains.