How to import a website into Figma Make

Figma Make turns a prompt into a working design — describe what you want, and it generates something you can shape further. But a prompt is a guess, and a guess rarely matches the real site you already have in mind. If you want Make to start from an actual website rather than a blank brief, the trick is to give it the real thing as a reference, not a description of it.

What Figma Make is (and isn't)

Figma Make is Figma's AI tool for going from intent to a working design or prototype. You write a prompt — or hand it an image or some pasted content as a starting point — and it generates a layout you can refine. It's genuinely good at conjuring something coherent from a description.

What it doesn't do, as of 2026, is reach out to a live page and pull that page's true, measured structure on its own. There's no "paste a URL and get the real site back" step. If you describe a site in words, Make builds its best interpretation of those words — which is a fresh design inspired by your prompt, not the actual page rendered faithfully. Make's capabilities are evolving, so this may shift; but today, a description is what it works from, and a description loses detail the moment you write it down.

Why start from a real site at all

Plenty of work isn't greenfield. You're not inventing a site from nothing — you already have one, or someone else does, and the task is to change it. A few cases come up constantly:

• Redesigns. The brief is "rework this page," and the page exists right now at a real URL. You want to explore alternatives against the actual layout, not a loose approximation of it.
• Audits and references. Sometimes you need the real thing on your canvas to study it — to measure it, mark it up, or compare new ideas against what's live today.
• "Make it like this, but…" The most common request of all. You have a reference site you admire, and you want to build something in its spirit. A prompt that tries to describe that site will drift; the real structure won't.

In every case, a prompt written from memory is a lossy copy of something that already exists in exact form. Why paraphrase the page when you can hand over the page?

The workflow: real site → editable layers → Make

The honest path is two stages: get the real website into Figma as editable layers, then use those layers as accurate reference material for Make. Here's how it goes:

1. Import the live URL into Figma as editable layers. Open a plugin like Vellum, choose URL as the source, and paste the link. The page is measured from the real browser render and rebuilds as a frame full of native layers — real frames, real text, real fills — not a flat screenshot. For the full range of ways in, see how to import a website into Figma and HTML to Figma.
2. Review the real spacing, type, and content now on your canvas. This is the part a prompt can't give you. You're looking at the actual layout grid, the genuine type scale, the true content lengths and colours — the things that make a design feel like the real site rather than a near-miss of it.
3. Use those layers as the faithful starting material for Make. Now you describe your Make project from what's actually in front of you — accurate proportions, real copy, the right hierarchy — or build on the imported structure directly. Either way, Make is working from the truth of the page instead of your recollection of it.

Be clear-eyed about the hand-off: Vellum imports into Figma design files, and the layers it produces are your reference and raw material — they don't auto-convert into a Make project, and there's no ".make" file to export. What you gain is a faithful starting point on the canvas, so whatever you do next in Make begins from something real.

What you gain over a blank prompt

The difference is fidelity, and it shows up everywhere. A prompt gives Make an idea of a site; an imported reference gives it the site's real measurements:

• Real content lengths. The actual headlines, the true paragraph runs, the genuine button labels — so the layout breathes the way the real page does, instead of stretching around placeholder copy.
• Real type scale. The exact sizes and weights the page uses, captured from the render — not a default Make happens to reach for.
• Real colours. The precise fills, gradients, and shadows, read off the live page rather than guessed from a word like "blue."

Put together, that means Make's output sits closer to the thing you're actually redesigning — because it started from the thing, not from a sentence about it. You spend your time refining a near-match instead of dragging a vague draft toward reality.

Limits to keep in mind

It's a workflow, not a magic button, and it pays to know where the edges are:

• Make is prompt-based and evolving. As of 2026 it generates from descriptions, images, and pasted content — not from a live URL's measured structure. What it can do is changing, so treat any specific capability as a moving target.
• The imported layers are a reference, not a one-click conversion. Vellum brings the real site into Figma as editable layers; it doesn't turn that into a finished Make project for you. The value is the accurate starting material — the building still happens in Make, by you.
• Animation and live media don't import as structure. Scroll effects, canvas, and WebGL on the source page have no static layout to rebuild, so they come across as a resting frame at best — not as motion you can carry into Make.

The bottom line

Figma Make is at its best when it has something real to start from. It can't fetch a live site's true structure on its own — but you can put that structure on the canvas first, by importing the page as editable layers measured from the real render. Do that, and a vague prompt becomes a faithful reference: real content, real spacing, real type, ready for Make to build on. Start from the page, not from a description of it.