Figma Plugin Privacy: What to Check Before You Import a Web Page
Check what a Figma plugin may reach (networkAccess) and what its vendor keeps (the policy) before you import a client or staging page. Dated 2026-11-01.
Figma plugin privacy depends on two separate things: what the plugin is allowed to reach, and what its vendor does with your page once it has it. The first is declared in the plugin manifest and enforced by Figma. The second lives in a privacy policy, and you have to read it. This article covers both, with one vendor policy and one product page checked on 2026-11-01.
If you import client pages, staging builds or a competitor's site, you are sending someone else's markup through a tool. That deserves five minutes of checking first.
What Figma lets a plugin reach: networkAccess and CSP errors
A plugin can declare a networkAccess field in manifest.json. According to Figma's network requests documentation, it has three properties: allowedDomains, reasoning and devAllowedDomains. The allowedDomains list names the domains the plugin may request, including external resources such as images loaded with createImageAsync(). Figma enforces the list. A request to an unlisted domain is blocked and a content security policy (CSP) error is thrown.
The values that matter
The plugin manifest reference defines a few special cases:
["none"]means the plugin cannot access any external network resources.["*"]permits any domain. A plugin that uses it must also supply areasoningstring.- An entry can be narrowed to a path, such as
httpbin.org/get, so other endpoints on that domain stay blocked. devAllowedDomainscovers local development servers, so they do not show up in the published list.
Where you see it
Figma shows the list of allowed domains, along with the reasoning text, on the plugin's Community page. That is the first thing to open. A plugin that converts markup you paste should have a short list. A wildcard with a thin explanation is a flag worth following up.
What the manifest does not cover
The manifest is a useful signal. It has limits, though, and Figma's own page on how plugins run states them plainly. The restriction applies only to requests the plugin itself makes, such as fetch calls.
Figma's example: if a plugin renders a website in an iframe, network access limits do not affect the resources that website needs. A plugin limited to figma.com could still show figma.com content, and that page could still load external resources such as scripts for Google Analytics. For an HTML import tool this matters, because rendering a page in a frame is exactly what many converters do to measure it.
Two more points follow from the same page:
- Plugin code in the main sandbox has no browser APIs, so
fetchand similar calls live in the iframe UI. When you review a plugin's behaviour, that is the side that talks to the network. - The manifest says nothing about what happens to data after it leaves your machine. Retention, region and logging are policy questions, not manifest questions.
Server-side conversion, a dated example
Some imports cannot run locally. If you give a tool a URL, something has to fetch that page, and the fetching happens on a server. That is a design choice with a real tradeoff: convenient for public pages, and a problem for anything private.
One documented example is html.to.design. Its privacy policy, last updated January 15, 2026 and checked on 2026-11-01, says that URLs, HTML or .h2d files are sent to its service to be converted into Figma designs. The table below uses only what that policy states.
| Input | Where it goes | Stored? |
|---|---|---|
| Pasted HTML | Sent to the service | "Processed in memory of our servers and not stored" |
| Public URL | Sent to the service | Result kept for 24 hours to serve the plugin |
| .h2d file from the Chrome extension | Stays local | "The file is never uploaded to our servers" |
The same policy lists log data (IP address, browser type, operating system and access times) and anonymous usage statistics. It states that processing servers are in the United States. It does not give a retention period for log data, so that part is unverified here. It also notes that your email address is collected from Figma only if you log in with Figma to send designs to the plugin.
To be fair to this approach: the policy is specific about what is and is not stored, and it offers a local path (the .h2d file) for people who do not want to upload anything. A server also lets a tool fetch and render live pages without any setup on your side. The cost is that your input leaves your machine, and you are trusting a retention statement.
How UnHTML behaves by default
UnHTML takes the opposite default. Per its own product page, the plugin "runs offline by default", makes zero network requests with default settings, and has no account and no upload step. Self-contained HTML files and Safari web archives carry their own assets, so there is nothing to fetch.
Three details matter if you are auditing it:
- Fetching remote assets and re-rendering JavaScript-built pages in a sandboxed frame is a single opt-in toggle, off until you turn it on. That step needs the network, which is why it is opt-in.
- The only call UnHTML makes on its own is a weekly licence check carrying just the licence key and a Figma user id.
- The CLI capture tool is separate from the plugin. For live sites it uses a headless browser to fetch assets, so network access happens when you run that tool yourself.
Offline has a cost. With remote fetching off, an HTML file that links to assets it does not contain will import without them. UnHTML produces faithful, editable layers, not an exact clone, and fonts that are not installed get substituted and logged in the import report. The privacy page has the full statement.
A checklist before you import
Use this list for any Figma import plugin, UnHTML included.
- Open the plugin's Community page and read the
allowedDomainslist and thereasoningtext. - Treat
*as a question to answer, not an automatic fail. Ask why a converter needs every domain. - Identify your input. A pasted file, a saved archive and a URL take different paths, and only the URL path requires a server to fetch the page.
- Read the policy for retention, region and log data. If a number is missing, as with log retention in the example above, record it as unverified.
- For staging or internal pages, prefer a self-contained HTML file or a web archive and a tool that converts locally. Public URL tools cannot reach private pages anyway. If you need a way to produce that file, UnHTML works from exactly those inputs.
- Date your check. Policies and manifests change, and a note saying "checked 2026-11-01" is more useful than a memory.
The takeaway
Privacy claims are easy to make and slow to verify, which is why the dated, sourced version is the one worth keeping. Everything named above comes from the vendor's own page. Anything I could not read is left out, not guessed.
The manifest tells you what a plugin may reach. The policy tells you what a vendor keeps. Neither replaces the other, and neither covers a page that loads its own scripts inside a frame. Check both, write down the date, and match the input type to the risk: URLs for public pages, files and archives for anything private.
Questions
- Can a Figma plugin read my page without sending it anywhere?
- Yes, if the plugin parses the HTML inside Figma and declares no external domains. Check the allowed domains on its Community page, and read its privacy policy for anything beyond the manifest.
- What does networkAccess none mean?
- Figma's manifest docs say it means the plugin cannot access any external network resources. Figma enforces it and blocks undeclared requests with a CSP error.
- Does a short domain list prove a plugin is private?
- No. It limits requests the plugin makes itself. It does not cover resources that a rendered website loads inside a frame, and it says nothing about what a vendor's server stores.
- How do I import an internal or staging page safely?
- Prefer a self-contained HTML file or a Safari web archive and a plugin that converts locally. A URL import needs a server to fetch the page, and public URL tools cannot reach private pages anyway.