How to Share Figma Prototypes with Clients

Figma gives you two ways to share a prototype: a full file link or a prototype-only link. The distinction matters more than most designers realize.

A full file link opens the design in the Figma editor. Clients can see every frame, layer, and component, which creates noise when all you want is feedback on the user flow. A prototype-only link opens the design in presentation mode, where clients interact with it like a real application. They click through screens, see transitions, and experience the flow without the distraction of design layers underneath.

To generate a prototype link, open your file in Figma, click Present in the right sidebar to enter presentation mode, then click Share prototype. From there you can copy the link or invite collaborators by email.

There is a catch. Prototype-only links with restricted permissions are a paid feature. On Figma's free Starter plan, anyone who receives a share link also gets access to the full design file in the editor. If you want clients to see the prototype without the underlying file, you need a Professional or higher plan.

What clients see with each link type:

• Full file link: every frame, layer, and component in the editor view
• Prototype link (paid plans): interactive presentation mode only, no editor access
• Prototype link (free plan): presentation mode, but recipients can also open the editor

This limitation drives many freelancers and small studios to look for supplementary tools that give them more control over what clients access and how they leave feedback. Figma holds roughly 40% of the design tool market and counts 95% of Fortune 500 companies among its users, so the sharing workflow is one most clients already recognize.

Helpful references: Fast.io Workspaces, Fast.io Collaboration, and Fast.io AI.

Figma's permission model is built around roles: Owner, Editor, and Viewer. For client sharing, Viewer is almost always the right choice. Editors can modify your designs, which is rarely what you want during a review cycle.

When sharing a prototype link, you control access at two levels:

Link-level access determines who can open the link. You can set it to "anyone with the link," "only people invited to the file," or "only people in your organization." For external clients, "anyone with the link" is the most practical option since it does not require clients to have a Figma account.

Role-level access determines what people can do once they open the file. Set this to "can view" for client reviews. On paid plans, you can further restrict this to prototype-only viewing.

A few permission settings worth knowing:

• Allow copying: toggling this off prevents clients from duplicating your frames, which is useful when sharing work-in-progress concepts you do not want copied
• Password protection: available on paid plans, this adds a layer of access control for sensitive projects
• Open sessions: Figma tracks who is viewing your file. You can manage open sessions and revoke access if a link gets shared beyond its intended audience

For teams working with multiple clients, managing these permissions per file gets tedious. This is where a dedicated file delivery tool starts to make sense, especially one that lets you set permissions at the workspace or folder level rather than file by file.

Sharing the prototype is half the job. The other half is collecting feedback that you can actually act on. Unstructured feedback over email costs more revision cycles than precise, anchored comments.

Figma's built-in commenting lets viewers leave comments directly on frames. Clients can click a specific spot on the prototype and type their note. This works well for visual feedback on individual screens, but it has gaps:

• Comments are tied to the Figma file, so clients need to be inside Figma to leave them
• There is no way to track which comments have been addressed without manually resolving each one
• Clients cannot comment on the flow between screens, only on individual frames
• Comment threads can get noisy on complex prototypes with dozens of screens

Setting up a structured review cycle:

1. Share the prototype link with a brief written context. Explain what you are testing, what stage the design is at, and what kind of feedback you need. "Does this checkout flow make sense?" is a better prompt than "What do you think?"

2. Give clients a deadline. Open-ended review periods drag on. A three-day window creates urgency without pressure.

3. Number your review rounds. Label each share as "Round 1 Review," "Round 2 Review," and so on. This prevents confusion about which version a client is looking at.

4. Consolidate feedback before acting on it. If multiple stakeholders are reviewing, wait until all comments are in before making changes. Responding to feedback piecemeal leads to contradictory revisions.

Design feedback tools like MarkUp.io, Ziflow, and Feedbucket exist specifically to fill these gaps. They let reviewers annotate directly on designs, track approval status, and organize feedback by round. But they add another tool to the stack, which means another login for clients and another system for you to manage.

Give Your Clients a Better Way to Review Design Work

Fast.io workspaces let you share prototypes, exports, and project files through branded portals with built-in feedback and version tracking. Free plan includes 50 GB storage and 50 shares, no credit card required. Built for figma prototype client sharing workflows.

Sign Up Free

Version control in Figma works differently than in code. There are no branches or pull requests. Instead, Figma auto-saves continuously and maintains a version history that you can browse and restore from.

Figma's version history lets you name specific save points (like "Client Review v1") and restore to them later. This is useful for tracking what you shared at each review round. But version history is tied to the file, not the prototype link. When you update the design, anyone with the existing link sees the latest version immediately.

That instant update is a double-edged sword. It means you never have to re-share links after making changes, but it also means clients might see work in progress if you forget to pause before a review session.

Strategies for managing versions across review rounds:

• Duplicate the file before each round. This gives you a frozen snapshot that the old link still points to, while you iterate on the working copy. The downside is managing multiple files.
• Use named versions in Figma's version history. After sharing a prototype, save a named version ("Shared with client - March 15"). If a client references something that changed, you can restore it.
• Create a page per round. Within the same Figma file, add a new page for each iteration. Set the prototype starting point to the current page. Previous pages serve as your archive.

For teams that share design files alongside other project deliverables like briefs, copy documents, and asset exports, a workspace that tracks file versions independently of the design tool simplifies this. Fast.io maintains version history for every uploaded file and lets you share specific versions through branded links without worrying about live edits overwriting what clients see.

Figma handles prototyping well, but it was not built as a client delivery platform. When projects involve more than just a prototype, you need somewhere to organize and share the full set of deliverables.

What Figma does not cover natively:

• Sharing exported assets, brand guidelines, and specs alongside the prototype
• Collecting files back from clients (brand assets, content, approvals)
• Providing a branded portal experience rather than a generic Figma link
• Controlling access after a project ends without revoking Figma permissions
• Tracking whether clients actually opened and reviewed what you sent

Options for filling the gap:

Google Drive or Dropbox work for basic file delivery. Create a shared folder, organize exports by round, and send the link. The limitation is that there is no feedback mechanism, no branded experience, and permissions are all-or-nothing at the folder level.

Notion can serve as a project hub where you embed Figma prototypes alongside other documentation. It is good for context-heavy projects where clients need to understand the rationale behind design decisions. The limitation is that file management within Notion is basic, and large asset libraries do not work well there.

Fast.io takes a workspace approach. You create a workspace for each client, upload design exports and supporting documents, and share through branded Send links. Intelligence Mode auto-indexes everything you upload, so clients can search across files and ask questions like "What are the primary colors in the brand guidelines?" and get cited answers.

What makes it practical for design teams:

• Branded Shares give clients a polished portal rather than a raw file browser
• Receive shares let clients upload brand assets, content, or signed approvals back to you
• Comments with anchors attach feedback to specific regions of images, pages of PDFs, or timestamps in video, which is useful when sharing screen recordings of prototype walkthroughs
• Granular permissions at the workspace, folder, and file level mean collaborators only see what they need
• Audit trails track who viewed, downloaded, or commented on every file

The free plan includes 50 GB of storage, 5 workspaces, and 50 shares with no credit card or trial expiration, which covers most freelance and small studio needs.

Best for: Designers and studios who deliver more than just a Figma file and want a single place for all client-facing assets.

Here is a step-by-step workflow that combines Figma's prototyping strengths with a structured delivery process. This works for both freelancers and in-house teams sharing with external stakeholders.

Before the first review:

1. Organize your Figma file. Name frames ("Home - Desktop," "Checkout - Step 2"), remove unused components, and set up your prototype connections. Clients will see frame names in the prototype navigation.

2. Test the prototype yourself. Click through every path, check transitions, and verify that hotspots are not overlapping. A broken prototype link during a client review damages credibility.

3. Save a named version in Figma's version history. Label it with the date and review round.

4. Export any supporting materials: annotated specs, asset libraries, or presentation decks.

Sharing for review:

5. Generate a prototype-only link. Set permissions to "anyone with the link, can view." If you are on a free plan and need to restrict file access, consider sharing a screen recording or a PDF export instead.

6. Write a brief for the client. Include what you are sharing, what stage it is at, what feedback you need, and a deadline for comments.

7. Upload exports and the brief to your delivery workspace. If using Fast.io, create a Send share so the client gets a branded link with all materials in one place.

8. Send the prototype link and workspace link together. The prototype link is for interactive review. The workspace link is for everything else.

After feedback:

9. Consolidate all comments from Figma and your delivery tool. Group them by screen or feature.

10. Make revisions in Figma. Save a new named version before sharing the next round.

11. Update the delivery workspace with new exports. The prototype link auto-updates to reflect your changes, but exported assets need to be re-uploaded.

12. Repeat until approved. Each round should have a clear label so no one confuses old feedback with current.

At handoff:

For final delivery, export production assets from Figma (SVGs, PNGs at required resolutions, CSS specs via Dev Mode) and upload them to a workspace the client can access long-term. If your client will need ongoing access, Fast.io's ownership transfer lets you build the workspace and then hand it off entirely while keeping admin access for future updates.