Model Context Protocol
Your assistant, holding the pen.
Connect Claude, ChatGPT, Cursor — any MCP client — to your Wedivo account, and it can read, design, edit and validate your invitation website itself. Same engine as the Design Creator, driven from the conversation you were already having.
One prompt, five tool calls, one invitation
Pick a prompt and watch the whole round trip — what your assistant asks for, what the server does about it, and the design that comes back. The transcript is a reconstruction; the invitation it ends on is a real published Wedivo design, loaded live.
Connect it once
Every MCP client discovers the rest from this one address. Pick yours.
https://mcp.wedivo.id/mcpSettings → Connectors → Add custom connector, and paste the URL. A browser tab opens for the sign-in.
https://mcp.wedivo.id/mcp
There is no API key to create or leak. You approve the connection in your own browser, with the same Google account you sign in to Wedivo with.
No design yet
Your draft
Server
12 / 12 · AI photo credits
Nothing spent — writing and editing are free
Everything your assistant can call
Eleven tools, plus the design rulebook served three ways so no client is left out. Tap any of them.
get_design_rulesToolReadsFreeWedivo's design rules and tool-call conventions, as a plain tool call — the fallback for clients that can't insert prompts or fetch resources.
Nothing you do in this demo is saved.
The tab you already had open
You are describing the wedding to an assistant anyway — the colours, the two families, the venue that has to look like it does in your head. The frustrating part is what happens next: you switch to another tab, describe it a second time, and spend the evening carrying results between two windows that can't see each other.
Connecting Wedivo removes the second window. Your assistant gets a set of tools it can call against your account, so "make the hero darker and move the gift section above the map" is a thing it does rather than a thing it tells you how to do. The draft lands in your Wedivo dashboard as if you had built it there, because you did.
It is the same engine either way. A design made through the connector opens in the Design Creator, edits the same way, and publishes to the same URL — the connector is a second door into one product, not a parallel one.
Eleven tools, one guest list of things it can touch
The server exposes eleven tools. Four are read-only — list your designs, fetch one's HTML, fetch just the {{fields}} it expects, check a draft against the validator. Four write — create a design, apply targeted edits to an existing one, generate an image asset, upload one your assistant made itself. Two more resume a slow image job and publish to the public gallery. The eleventh hands over the design rulebook.
Scope is decided by the server, never by the client. Your assistant can list and open your own designs and anything already published; someone else's private draft simply does not exist as far as its tools are concerned. Publishing to the public gallery is reserved for Wedivo's own curators, exactly as it is in the browser.
It is handed the same rulebook the Design Creator gets
An invitation is not a web page with nice fonts. It has a metadata contract, {{parameter}} fields that get filled per guest, widget markup the RSVP and gift sections hook into, and a phone-first performance budget it has to survive. An assistant given none of that produces something that looks right and works nowhere.
So the rulebook ships three ways — as an MCP prompt, as a resource at wedivo://design-rules, and as a plain tool call — because clients differ in which of those they support and none of them should be the reason your design comes out malformed. Whichever route it takes, the text is identical to what Wedivo's own generator is given.
Then validate_template checks the result against the same validator the web editor runs, and will optionally attempt an AI repair pass on what it finds. Nothing is saved by that check: it is a dry run your assistant can take as many times as it likes before committing.
Images take as long as images take
Image generation is slow and unpredictable — routinely tens of seconds per asset, sometimes far worse. Waiting on a batch of them inside a single tool call is how a connector times out with nothing saved, so create_template never does. It saves the draft the moment the HTML validates, marks the images pending, and hands back an id.
Your assistant then calls continue_image_generation with that id until the job reports complete, a few assets at a time. Long calls send progress heartbeats while they work, so a client watching for signs of life gets them instead of deciding the server died mid-render. Leave and come back and the job is still exactly where it was.
If your assistant makes its own images, it can skip Wedivo's generator entirely — hand upload_image the result and it goes through the same resize, crop and hosting pipeline every other asset does, coming back as a URL to drop into the design.
One sign-in, re-checked on every single call
There is no API key to create, paste or accidentally commit. Your client discovers the server, registers itself, and sends you to a Wedivo page where you sign in with Google and approve the connection once. That is the whole setup — it is the standard OAuth flow every MCP client already implements, with PKCE required rather than optional.
The token it gets back is short-lived, and what it is allowed to do is never read from the token. Every request re-reads your account from Wedivo first, so access removed at 10:00 is gone at 10:00 — not whenever the token happened to expire. An account that does not already exist on Wedivo is refused outright: the connector signs you in, it never signs you up.
Every call is recorded with the same step-by-step log a design built in the browser produces — which tool ran, what it did, how long each step took, and whether it worked.
You pay for pixels, not for prose
Writing an invitation through the connector is free, however many times you do it. The HTML came out of your own assistant, on your own subscription — Wedivo did not run a model to produce it, so Wedivo does not charge you for it. Creating, editing, reading, validating and publishing all cost nothing.
What does cost something is artwork. When you ask Wedivo to render illustrations — an ornament, a cut-out bloom, a divider — that is Wedivo's image model doing the work, and it takes one AI photo credit, out of the same balance your prewedding photos come from. One credit for the design, not one per picture: an invitation needing eight illustrations costs exactly what one needing a single ornament costs.
It is taken once, by whichever call renders first, and never again for that design — so resuming a slow image job, or coming back a week later to add another flourish, costs nothing more. If the render produces nothing, the credit comes straight back. And you can skip it entirely: if your assistant makes its own images, upload_image puts them through Wedivo's pipeline for free.
MCP Connector
Everything it does
Design and edit
Images
Connecting
Guardrails
Included in
Connecting an assistant and building invitations with it is free on any plan — your model does that work, not ours. Only Wedivo-rendered artwork costs anything: one AI photo credit per design, however many illustrations it needs, from the same balance as your prewedding photos, which paid plans carry. Bring your own images and even that is free.
See pricingWorks with
Point your assistant at your wedding.
One URL, one sign-in, and the next invitation it designs is one you can actually publish.