PRIVACY POLICY

Your captures.
Your choices.

Saved captures, local handoffs, usage analytics, feedback and capture reports have different destinations. Read the full policy below.

Lillabr privacy policy

Website policy update — 15 October 2026. This policy is published on the Lillabr website and describes how Chrome 1.0.6 (the first Chrome version after 1.0.4) and the Lillabr Import plugin handle your data. Marked as Chrome 1.0.6 and later, it describes the optional AI features, including the AI connector link and that, while Cloud sync is on, a capture made through it is also uploaded to Cloud sync, and optional Google sign-in, which capturing never needs: what Lillabr stores for an account, the email it may send, and the welcome page that opens once when the extension is newly installed. It also describes the short announcements Chrome 1.0.6 reads from Lillabr's website for its toolbar icon and panel, and four further changes in Chrome 1.0.6: Lillabr's panel is now Chrome's own side panel; you agree to this policy and the Terms of Use with a box on the first capture step; in a new installation that agreement also starts usage analytics, which no longer has a switch; and Lillabr may ask three short questions about your first capture (see Feedback after your first capture). It also describes four more things Chrome 1.0.6 does: the panel keeps a picture of each of your recent captures, drawn from the capture itself, in your browser, shows it for up to 7 days and deletes it at your next capture after that, and the thumbnail uploaded with a saved capture is drawn the same way instead of being a screenshot of the tab; you can send Lillabr a report about a capture in which something did not come through (see Reporting a capture, at the end of Feedback after your first capture); while it shows a setup code, the panel asks Lillabr's sync service whether the Figma plugin has taken it; and the demo banner opens Google Calendar's booking page, which the panel and the website load only when you press its button. Practices specific to these builds apply when you use them. Website publication does not confirm that any update is available in its marketplace; check the official Chrome Web Store and Figma Community listings for available versions. An older Chrome (1.0.2) kept Cloud sync Off until you enabled it in Settings, and Chrome 1.0.4 turned it on when you chose Start capturing & sync. In Chrome 1.0.6 that Settings switch is called Save captures (this policy also calls it Cloud sync, and its uploads Cloud uploads), and a new installation turns it on when you agree to this policy and the Terms of Use on the first capture step, as described below. The embedded-frame capture and masking protections introduced in 1.0.1 are retained.

This update also describes the optional account-connected Lil Labr plugin for AI apps that support its MCP connection. It reads saved captures by reference after you approve the app through your Lil Labr account. Where enabled, the dashboard at https://app.lillabr.com provides Google sign-in and connection consent; the compatible Chrome extension also supports the earlier consent route. Availability depends on the compatible account and host connection; this policy does not establish that the plugin is listed or approved in a marketplace. Where available, a separately approved Browse saved captures permission also shows saved-capture metadata and preview thumbnails in an embedded gallery, before you select a capture for the chat.

First-party hosting and transport. Vercel hosts Lillabr's website and dashboard and routes requests at https://api.lillabr.com and https://mcp.lillabr.com to the developer-operated services on Supabase. Depending on the feature you use, those requests can carry account and sign-in information, session credentials, one-use handoff and connection references, capture metadata, previews, assets, archives and connector messages. Vercel processes this information in transit as a hosting and transport provider. Supabase continues to provide the backend functions, database and storage described below. Hosting providers can process request addresses, headers and IP addresses under their own logging practices. The feature-specific retention, deletion and service-operator access rules below continue to apply.

The short version

Usage analytics sends limited Lillabr actions and outcomes to PostHog under a random ID, never captured page content or URLs. In a new installation of Chrome 1.0.6 it starts when you agree to this policy and the Terms of Use on the first capture step, and nothing is sent before that; an installation updated from an earlier version keeps the choice it had, so analytics that was off stays off. The Figma plugin shares usage analytics unless you turned it off in an earlier version. Neither the Chrome panel nor the plugin has a switch for it any more: to object, write to the contact address below. See Usage analytics.

Before you agree to this policy and the Terms of Use on the first capture step (the box "I agree to the Privacy Policy and Terms", then Capture full page), Lillabr captures nothing and does not upload captures to its sync service. In a new installation that agreement turns Save captures (Cloud uploads) on, for that capture and future captures; an existing explicit Off preference stays Off. The latest capture is also held temporarily in the extension’s local browser storage so clipboard copy and Download capture can be retried, and any .labr file you choose to save goes to your Downloads folder. Chrome 1.0.6 and later also keep, in the extension's own local storage, a picture of each of your 24 most recent captures (drawn from the capture itself, with its title and page address) and the details that a report about that capture would carry (counts, codes, font names and the names of other websites), each expiring after 7 days at most (a day for a capture made in an Incognito window) and deleted at your next capture after that; Forget latest capture deletes its own, and nothing of this is kept for a capture an AI app asked for. The limited asset and font requests described below go only to the page’s resource hosts or jsDelivr.

Agreeing on the capture step changes where captures are stored. The popup behind the words "Privacy Policy and Terms" on that step says that each capture is saved on Lil Labr's servers for 7 days so the Figma plugin can import it; once you agree, Cloud uploads are on for successful captures in a new installation. An installation updated from a version before 1.0.6 is not asked again: it is recorded as having agreed, and its Save captures and analytics choices stay as they were. An existing explicit Off preference remains off after an update, and pairing while uploads are off does not resume uploads. The whole capture, plus a thumbnail of the page, is uploaded to a sync service so Lillabr Import can list and import it without you saving a file. The service is operated by the Lillabr developer. Lillabr uses HTTPS to send data to this service but does not apply end-to-end encryption: the developer can read every page you sync. You can pause uploads with the Save captures switch in Settings and use direct paste or Download capture instead. See Send to Figma (sync) below; that section describes Cloud uploads.

The optional AI connector link is a separate path that passes captures through Lillabr's cloud (Chrome 1.0.6 and later). If you create a connector link and add it to Claude, ChatGPT or Codex, a capture that app asks for goes from your Chrome through Lillabr's cloud to the app, which reads it there. It does not exist until you create the link, which needs a Google sign-in (Set up next to Claude or ChatGPT in the panel); each website still needs your Allow in Chrome, and the cloud copy is encrypted with a key from your link and expires an hour after the app last reads it, a day at most. It is not end-to-end encrypted: the service handles your link while it answers, so the developer, who operates it, could read captures while they exist. Pause, Reset link and Turn off, in Settings while a link exists, control it. While Cloud sync is on, a capture the app asks for is also uploaded to Cloud sync, like one you make yourself, where it is not encrypted with your link's key (see Send to Figma (sync)); with Cloud sync off it is not. See The optional AI connector link below.

The optional account-connected Lil Labr plugin reads captures already saved in your account. You approve an AI app through your Lil Labr account, then give it a capture or flow reference. Its read permission covers your account's saved-capture workspace; it is not a separate permission for each capture ID. Without separate browse permission, the app cannot list your saved captures or their thumbnails. With explicit captures:browse approval it can show saved capture metadata and preview images in a gallery, where you choose a reference to bring into the chat. Previews can contain visible page content. The plugin cannot start browser captures or edit the source website. It can return the saved content and available assets, or a short-lived link to the whole original archive. Saved captures retain their existing seven-day/newest-50 limits. Removing the connection in an AI host does not guarantee revocation unless the host also revokes its authorization. See The optional account-connected Lil Labr plugin.

Optional Google sign-in (Chrome 1.0.6 and later). Chrome 1.0.6 can offer you a sign-in with Google, but only once Lillabr has turned sign-in on at its server; until then it shows no sign-in, like earlier versions. Signing in is optional, and capturing never needs it, however many captures you make. It keeps your progress across browsers, and you need it to use Claude or ChatGPT with Lillabr. Signing in gives Lillabr your Google account ID, your email address, your name and, with your first sign-in on a browser, your answer to the optional product-news box on the first capture step, which is off unless you tick it. Lillabr uses them to run your account and Cloud sync, to email you about your account and about Lillabr, and, only if you ticked the box, to email you product news. Lillabr never receives your Google password, does not sell your email address and does not use it for advertising. Without signing in you can capture, copy or save captures, open files and use Settings. After a new install the extension also opens Lillabr's welcome page once. See Signing in with Google below.

The Figma plugin can also open a .labr file you choose on your computer. Opening that file does not upload it to Lillabr's service. Importing it creates layers in your Figma file, which Figma handles under its own terms and privacy policy. A paired plugin contacts its paired sync service to list and download captures that were uploaded earlier. Fresh connections use the developer-operated Lillabr service; the retained older-connection exception is described in What the Figma plugin does below.

Usage analytics and Save captures are separate. In a new installation the one box on the capture step starts both; turning Save captures off does not stop analytics, and analytics never uploads a capture. See Usage analytics below.

Feedback after your first capture (Chrome 1.0.6 and later). Once Lillabr switches it on, the panel or the welcome page may ask you three short questions about your first capture: a score for each and, below the top score, a few words. The answers go to Lillabr's account service with the app version and where you answered, never with your account, email address, a capture or your IP address, and are kept 12 months. Skipping sends nothing. See Feedback after your first capture below.

Reporting a capture (Chrome 1.0.6 and later). If something on a page did not come through, Something didn’t come through? in the panel opens a report about that capture. No report is sent until you press Send report, and under What we send the panel shows the exact report: the boxes you tick, your optional note (email addresses, web addresses and long numbers are taken out of it), the page's address without anything after ? or # if you leave that box ticked, versions, and counts, codes, font names and the names of other websites about the capture. A report never holds page text, the page title, form values, images, cookies, your IP address or an account or device id (please do not write personal information in the note). Lillabr's account service keeps it 90 days, with the day it arrived and no account, device or IP address. Send report is offered only while Lillabr has switched reports on, and they are off until it does; meanwhile the panel offers to save the report as a file for you to email yourself. See Reporting a capture, at the end of Feedback after your first capture.

A successful capture writes the prepared payload to the system clipboard. Operating-system clipboard history or sync, security software, and third-party clipboard managers may retain or transmit clipboard content independently of Lillabr. Clear the clipboard and any clipboard history after capturing sensitive material.

Limited Use and access to user data

Lillabr's use of user data adheres to the Chrome Web Store User Data Policy, including its Limited Use requirements. Data is used only to provide, maintain, secure, and improve Lillabr's disclosed capture and Figma import features and, from Chrome 1.0.6, its optional AI assistant features. From Chrome 1.0.6 it is also used for the optional Google sign-in: running your account and Cloud sync, and sending the account, service and (only if you opt in) product-news email described in Signing in with Google. Lillabr uses your account data for no other purpose. Usage analytics measures the use, performance, and reliability of the capture and import features, answers to the optional feedback questions are used only to improve Lillabr (in Chrome, the three scores also decide, in your browser only, whether the screen after them asks you for a Chrome Web Store review; see Feedback after your first capture), and capture reports you send are used only to find and fix what Lillabr's captures miss. Lillabr does not sell user data or use it for advertising, data brokerage, credit, or lending decisions. It does not transfer your email address or name to anyone except the service providers that host it for Lillabr (Supabase and Vercel today) or, once Lillabr chooses one and names it here, send email for Lillabr; where the law requires it; or to protect against abuse, spam or fraud.

The developer's technical ability to read synced captures is not permission for unrestricted human access. Human access is limited to the specific data you explicitly authorize for support, necessary security investigations, legal obligations, or aggregated and anonymized internal operations as permitted by the Limited Use requirements. Routine analytics review uses aggregate feature reports.

What Lillabr does with the page you are on

Lillabr's panel is Chrome's own side panel (Chrome 1.0.6 and later; earlier versions showed a panel inside the page). It starts closed. Choose the Lillabr toolbar icon on a tab to open that tab's panel, and choose it there again to close it: Chrome shows the panel beside that tab's page, hides it while another tab is in front (that tab has no Lillabr panel unless you open one there) and shows it again when you come back, and the panel works on its own tab only. Closing the tab closes its panel. While a Lillabr side panel is open for any tab, even one hidden behind another tab, Lillabr's capture script runs on your web pages (those you open then, and, while browser-agent tools are on, those already open), so a flow can be captured without returning to the toolbar and browser agents can be offered Lillabr's tools (see below); the panel itself is not part of any page and never appears in a capture. Closing the last open Lillabr side panel stops the script from being added to new pages and withdraws the tools. After a new install of Chrome 1.0.6 or later, Lillabr also opens its own welcome page, https://lillabr.com/welcome/, in a new tab once; that captures nothing (see Signing in with Google).

After an update (Chrome 1.0.6 and later). Versions before 1.0.6 drew their panel inside the page, and an update can leave such a panel, whose buttons no longer work, on the tabs that are open. Every time Lillabr is updated, it runs a small script once in the top page of every open tab that holds a web page or a local file it may read (not Chrome's own pages or the Chrome Web Store). The script looks only for the elements of that old panel and of its capture animation: it hides the old panel where it finds one (it moves it into the page's <head>, where nothing is drawn, and keeps it hidden and unclickable) and removes the old capture animation. It reads nothing else on the page, changes nothing else and sends nothing anywhere. Lillabr's capture script does the same the first time it is put on a page.

The panel does not inspect page content or upload a capture just because you visit a page. A capture starts when you choose a capture action or use a Lillabr shortcut, and only once you have agreed to this policy and the Terms of Use on the first capture step (an installation updated from a version before 1.0.6 counts as having agreed); a capture asked for before that, by you, a browser agent or an AI app, is refused. From Chrome 1.0.6 it can also start at the request of a browser agent, or of the page's own scripts, while a Lillabr side panel is open for any tab (see the next paragraph), or of an AI assistant you connected yourself (see The optional AI assistant link and The optional AI connector link). Closing the side panel does not stop shortcut capture requests.

Browser agents (WebMCP), Chrome 1.0.6 and later. While a Lillabr side panel is open (for any tab, even while another tab is in front), an AI agent built into or connected to your browser that supports WebMCP, or the scripts of the web page itself, can use five Lillabr tools on the web pages you open: read the capture status, start a screen capture, a full-page capture or an element pick of that page, and save the capture it just made as a .labr file in your browser's download folder (it is told only the file name). Because a page's own scripts can use these tools as an agent can, the web page in front can, without asking you, have Lillabr capture it (at most once every 3 seconds), save that capture to your download folder, and read the capture status, which says whether Save captures is on and the mode, size, counts and time of your latest capture, whichever website it was made on, never its title, address or content. This is on by default, and the popup behind "Privacy Policy and Terms" on the capture step says so; closing the last open Lillabr side panel withdraws the tools. A capture an agent starts is kept on this device: it is not copied to your clipboard and not uploaded, even with Save captures on, unless you press Save capture on it yourself in the panel. An agent can save only a capture its own request made, at most 20 an hour.

When you do ask for a capture, Lillabr reads the page in the browser tab you are looking at: the position and size of each element, its colours, borders, shadows, fonts and text, and the images it uses. It turns all of that into a snapshot. From Chrome 1.0.6 it also counts, on your computer, the kinds of elements and CSS features the page uses and which of its web fonts loaded; those counts stay in your browser unless you send or save a capture report (see Reporting a capture, at the end of Feedback after your first capture).

In Chrome 1.0.1 and later, that includes what is shown inside frames embedded in the page (<iframe>), such as an email preview or a chat launcher, because they are part of what you see. For a frame served from another site, Lillabr runs the same capture code inside that frame, using the same website access, and adds what it drew to the snapshot. A frame that cannot be read stays an empty placeholder. Chrome 1.0.0 leaves embedded frames as placeholders.

Where a snapshot goes

A production capture from the panel can go to these local destinations, plus the optional sync destination described further down:

  1. Lillabr's local retry cache. The current .labr capture is stored in extension-origin IndexedDB. When native conversion succeeds, the exact Figma-compatible clipboard HTML is stored next to it so a failed or later copy can be retried. This cache is not Chrome Sync storage.

  2. Your clipboard. Capture prepares and writes the native-Figma payload to your system clipboard. The post-capture Copy to Figma action writes the cached payload again. Clipboard history, sync, security software, or a third-party clipboard manager can retain or transmit it outside Lillabr's control even after you copy something else.

  3. Your Downloads folder. Chrome saves a .labr file only when you click the Download capture button on the latest capture; from Chrome 1.0.6, when you click Download all N pages in the panel's Recent tab (the pages of your current flow, downloaded from the sync service and joined into one .labr file; see Send to Figma (sync)); or, from Chrome 1.0.6, when a browser agent saves the capture it just made (see Browser agents above). A capture report you choose to save (Download report, see Reporting a capture) is a .json file in the same folder. A saved file is separate from the local retry cache and stays until you delete it.

  4. Lillabr's pictures of your recent captures (Chrome 1.0.6 and later). After a capture has finished, Lillabr draws a picture of it from the capture itself (a thumbnail 320 pixels wide and a full view at most 720 pixels wide and 16,000 pixels tall, never a screenshot of the tab) and keeps it in extension-origin IndexedDB with the page title and address (origin and path), so that the panel can show it when you press the capture's thumbnail. The pictures of the 24 most recent captures are kept, each expiring after 7 days at most (a day for a capture made in an Incognito window). See What the Chrome extension stores in the browser.

With Cloud uploads off, captures are not uploaded to Lillabr’s sync service. With Cloud uploads on, they are uploaded to the developer-operated service, which can read them. Turn Save captures off before capturing a page you do not want to upload. Direct paste and saved .labr files remain available as local handoffs. Page asset and font requests are described separately below.

Direct copy remains local until you paste into Figma. After that user action, Figma handles the pasted content under Figma's own terms and privacy policy. If you independently move a Lillabr artifact through another import product, that product's processing and privacy terms apply; do not use a third-party route for private captures unless you have reviewed it separately.

A capture an AI app asks for through the optional AI connector link (Chrome 1.0.6 and later) uses none of these local destinations: it is not copied to your clipboard, is not saved to Downloads, does not replace your latest capture and leaves no picture behind. It does pass through Lillabr's cloud to that app, and while Cloud sync is on it is also uploaded to Cloud sync, like a capture you make yourself, as described in The optional AI connector link.

Lillabr can be connected to an AI app on your own computer (Claude Desktop, Claude Code, Cursor and the like) through lillabr-mcp, a separate local program that you install in that app. Nothing is connected until you do that and approve it in Chrome, though the extension looks for a local server on your computer all the time (see the first point below). It is not a Lillabr cloud service and Lillabr uploads nothing for it. This section is only about that local link. An AI app that runs in the cloud, such as Claude on the web or ChatGPT, cannot reach your computer this way; for those, Chrome 1.0.6 and later offers the separate connector link described next, which does pass captures through Lillabr's cloud.

  • The connection stays on your computer. The extension connects out to ws://127.0.0.1 on ports 47831 to 47835, your own machine, and only to a server that proves a secret you approved. To find one it tries those ports about every 30 seconds while Chrome runs, in every installation, whether or not you ever use an AI app (the alarms permission); nothing leaves your computer for that and no capture is made without your Allow.
  • You approve it, at both ends. Chrome's panel shows a six digit code; you tell your AI app the code and click Allow in the panel. Neither alone connects anything. Settings has Disconnect assistant, which deletes the secret and the websites you allowed.
  • You decide which websites. The first time the assistant wants to capture a website (this includes the tab you are on), Lillabr asks in a small window of its own. Allowed websites are remembered until you disconnect or choose Forget allowed websites; a refusal is remembered for 10 minutes. Until you have allowed a site, the assistant is not told which page you are on.
  • What the assistant receives. For a website you allowed, the assistant can ask Chrome to open an address on it in a separate window and capture it, including anything you are signed in to on that website, and then reads the .labr capture: page text, images and visible form values (password fields are masked). Unless the app asks for none, Chrome also takes a JPEG screenshot of the visible part of the page (128 KB at most; when several pages are captured in a row, none unless the app asks, and then for at most four of them) and hands it to the app with the capture; it shows whatever was on screen, including form values the capture masks, and Lillabr does not keep it. The capture is saved as a file on your computer and handed to the AI app you connected; what that app does with it is governed by that app's provider, as with anything you paste into its chat. Link addresses it is told, and those stored in the file, lose user names, passwords and query parameters named like secrets, which is a rule of thumb by name. Captures made for the assistant are not copied to your clipboard, not uploaded by Lillabr (even with Cloud sync on) and do not replace your own latest capture.
  • What Chrome keeps. In extension-local storage: the pairing secret for each server you approved and the websites you allowed (their addresses, not what was captured). Counters for rate limits and refusals are in session storage, which Chrome wipes when it closes. The local program keeps a random id for itself and the secret in ~/.lillabr/server.json and the captures in ~/Lillabr, readable by your account only.

Chrome 1.0.6 and later. Lillabr can give you a private link to add to an AI app, whether it runs on your computer, on another device or in the cloud: Claude (web, desktop and phone), ChatGPT (web, on the plans that allow custom connectors), Codex or Claude Code. The app can then ask Lillabr, in your own Chrome, to capture a website, and can read the capture. Because the link is a web address of Lillabr's service rather than a program on your computer, a capture made this way passes through Lillabr's cloud, even when the app runs on your computer. Nothing is set up until you sign in with Google and create a link (Set up next to Claude or ChatGPT in the panel; without a sign-in they cannot be used), after agreeing to this policy and the Terms of Use and to a short disclosure about this feature. The Save captures (Cloud sync) switch neither turns it on nor off, and the link has tokens of its own, not Cloud sync's. The switch does decide one thing: while Cloud sync is on, each capture the app asks for is also uploaded to Cloud sync, like a capture you make yourself (see The Cloud sync copy below).

  • How a request travels. The AI app sends its request to the Lillabr connector service, which the developer operates on Supabase at https://api.lillabr.com/functions/v1/connector. Its database and storage are in US East; a request may be handled by the Supabase location nearest to the app that sent it, which opens the capture there while it answers. While a link is on and not paused, Chrome keeps one secure WebSocket (wss) connection open to that service and takes requests from it. The capture goes from Chrome to the service, and the app reads it from the service. Claude's apps and ChatGPT send their requests from their provider's cloud; Codex and Claude Code send them from your computer. Chrome has to be open: if it is not, the app is told Chrome is not connected, and captures already made stay readable until they expire.

  • What your Chrome sends. Chrome makes two random secrets: the link, and a second secret that only Chrome uses to prove to the service that it is your Chrome. Creating the link sends only a one-way hash (SHA-256) of each, the last four characters of the link, the extension version and Chrome's version number; the service never receives either secret then. Afterwards Chrome presents its second secret to the service as its password, over HTTPS and in the first message of each connection, and sends a small signal every 20 seconds to keep the connection open. For each capture you allow, Chrome sends the whole .labr archive (up to 24 MB; see What is inside a snapshot file: visible form values may be kept, and password and card fields are masked), the page title and address, the page's links (their text and addresses, which lose user names, passwords and query parameters named like secrets), counts of layers, images and warnings, and a JPEG screenshot of the visible part of the page that the AI app can ask to leave out (about 80 KB at most; a multi-page request sends none unless the app asks, and then about 20 KB each). The screenshot shows whatever was on screen, including form values the archive masks. The service also receives each request the AI app makes: the address to capture and a few options.

  • What the service stores. For your link: the hashes of its two secrets, its last four characters, the extension version, when Chrome last connected and when the link was last used, and whether it is paused. For each request: its progress, times and sizes, and the request, the result and the capture as encrypted data. Counters for the limits below, including, for up to two days, counters kept under a keyed hash of the IP address that created the link or opened a connection (not the address itself). It does not store the link or Chrome's second secret, or the Chrome version.

  • How it is protected, and how far. Each request, result, capture and its description is encrypted (AES-256-GCM) in Chrome or in the service, with a key made from your link. The service's database holds only a hash of the link, so a leaked database or storage file, or a stolen service key, would expose encrypted data, sizes and times, but not what was captured. This is not end-to-end encryption: your AI app gives the service the link with every request, and the service uses it to open a capture for as long as it takes to answer. The developer operates the service and its code, so the developer could read captures while they exist. Supabase and Vercel, which host and route the service, may also record the address of each request in their own logs, and your link is part of that address (the header form that Codex and Claude Code offer keeps it out of the address). How long each provider keeps such logs is that provider's decision. The service's own logs never contain links, requested addresses, requests or results; while Lillabr checks compatibility they may record which AI app connected (its name, the protocol version it speaks, the kind of program it is and the website it ran from, never the link or anything captured). The Limited Use rules above apply to all of it.

  • How long captures are kept. A capture can be read for 60 minutes after the app last read it, and never later than 24 hours after it was made. A link keeps its newest 20 captures and 150 MB at most, so older ones go sooner. The encrypted result of a request (its title, address, links and screenshot) is kept for 60 minutes after the request ends. The app cannot read anything after it expires. The service deletes what has expired at its next clean-up, which runs at most once a minute whenever any Chrome connects to the service (a connected Chrome reconnects every couple of minutes) or an AI app makes a request; only while nothing at all uses the service does expired data wait longer, for the next one that does. A link that Chrome never connected to is deleted after an hour, and a link nobody has used for 90 days is deleted. Reset link and Turn off remove the link's captures and results at once, and Delete now removes its captures and the results of the requests that are over.

  • What someone who has your link can do. Ask for captures; read the captures made through the link until they expire; and see whether Chrome is connected, when it was last seen, the extension version, the websites being captured and the titles and addresses of the newest captures. They cannot capture a website you have not allowed, see the tab you are on, read your own captures, or answer for Chrome. Treat the link like a password: the AI app stores it so it can call the service, and anyone you share that app's settings or a configuration file with can get it. Reset link makes the old link stop working.

  • You decide which websites. The first time an app asks for a website, Lillabr asks you in a small window of its own, never in the page. Allow lasts 24 hours and is kept apart from the local link's list; a Don't allow is remembered for 60 minutes. A request for the tab you are on always asks, and Allow then covers only that capture. The window shows a four-character request code that the AI app shows too, so you can tell whether the request is yours, and a link to pause the connector if it is not. Websites on your own computer or network, such as localhost, private addresses and local names, are refused; a public website name that points to an address on your network is not caught by its name, so check the website named in the window. Chrome asks at most 4 times in 10 minutes and makes at most 20 connector captures an hour; the service allows 20 captures an hour and 100 a day for a link.

  • What Chrome keeps for an AI app's capture. It is prepared like any capture, but it is not copied to your clipboard and does not replace your latest capture, and Chrome deletes its copy once it is sent (and, while Cloud sync is on, once it has also been uploaded to Cloud sync). A capture of a website you allowed can include anything you are signed in to on that website.

  • The Cloud sync copy. While Cloud sync is on, the complete .labr archive, a thumbnail and the page details of an AI app's capture are also uploaded to your Cloud sync workspace and its current flow, so the Figma plugin lists it and you can import it, as for a capture you make yourself. This copy is not encrypted with your link's key: it is stored and kept as Send to Figma (sync) describes (seven days, the newest 50 per workspace), and the service operator can read it. Reset link, Turn off and Delete now remove the connector's copies, not this one: delete it in the Figma plugin (Delete page or Delete flow), or turn Cloud sync off before you ask an AI app for a capture you do not want uploaded. The local AI link and browser-agent captures are still never uploaded on their own.

  • What the AI app does with it. Everything a capture, preview or link list contains goes to the app, and its provider's terms and privacy policy govern it from there, as with anything you paste into its chat. A web page can contain text written to mislead an AI app. Lillabr labels everything from a page as untrusted and asks you before each website, but cannot control what the app does with a capture.

  • Chrome stays connected. While a link is on and not paused, Chrome holds the connection open and wakes Lillabr's background worker about every 30 seconds to reconnect if needed (the alarms permission), which uses a little power and network. Pause and Turn off end it.

  • Your controls. In Settings, AI connector (shown while a link exists, whether or not you are still signed in): Copy link, Pause and Resume, Reset link, Turn off, Delete now (every capture stored through the link) and Forget allowed websites. Lillabr's own setup page shows the full link and a log of recent requests.

The optional account-connected Lil Labr plugin

Where this connection is available, an AI app can read a saved screen or flow you reference in a chat. You approve that app through your signed-in Lil Labr dashboard, where enabled, or its compatible Chrome consent route. This account connection is separate from the local AI assistant link and the personal AI connector link described above. It does not give the app your Chrome extension's device credential or your Google password.

  • What you authorize. The app receives an account-level captures:read permission for your saved-capture workspace. It can read an available capture or flow when it supplies its reference. The tools are designed to open the references you give in a chat or select in the gallery. It has no browser capture or editing tool. Approval is not a separate access restriction for each capture ID: a connected app with a valid reference can read that saved content in your account. A copied capture or flow ID identifies the reference; it is not an access token and does not let another account read your captures.

  • Optional gallery permission. Browsing saved captures additionally requires explicit captures:browse approval. The permission request shows both captures:read and captures:browse before you approve it. Existing reference-only connections keep their original permission; a server update or token refresh does not add browsing. To use the gallery with such a connection, start a new authorization and approve the additional permission. The gallery can list metadata for available captures in your account and show their stored preview thumbnails, with title search and pages of results. It does not give the app access to another account's captures.

  • What the gallery shows. Capture references, titles, source addresses, capture mode, dimensions and counts, saved/expiry dates, and available preview thumbnails go to the embedded interface in the AI host. Thumbnails are actual captured image content and may show page text or other visible information; they are not anonymous or content-free metadata. The gallery uses stored thumbnails and does not open every original archive to create them. Its normal assistant-facing result is a count/status summary; metadata and thumbnails are supplied to the embedded interface. Selecting a card and choosing Use selected sends only the chosen capture references and their title, capture mode, dimensions and element counts into the conversation. The selection check does not open original archives. When you request work, reader tools can fetch the selected content and original assets. The host and its provider handle interface data under their own policies.

  • What the app receives. Saved page text, titles and addresses, recorded form values where present (subject to the capture's masking), font information, colors, layout measurements, available images and SVGs, and capture warnings. It can obtain a download of the original .labr archive. Font files are available only when actually embedded; otherwise the plugin returns recorded metadata and original font source URLs. Larger assets may be supplied through a download of the whole archive, including its other saved content. Captured page text, image text and SVG markup are untrusted page content, not permission for the AI app to take other actions.

  • Where the capture is kept. The plugin reads the captures already uploaded through Save captures. It does not store another capture copy or extend the saved lifetime: the existing sync limit remains seven days and the newest 50 captures. Expired, removed or unavailable references cannot be opened through the connected account. The existing sync disclosure about Supabase hosting, service operator access and lack of end-to-end encryption still applies. Download links last at most five minutes, limited by the capture's remaining lifetime. Anyone given a working signed download link can use it until it expires; it downloads the whole original capture.

  • Connection data and lifetime. Lillabr stores the account/workspace and app associated with the authorization, the app's name and registered callback addresses, authorization dates, and one-way hashes of access tokens, refresh tokens, authorization codes and any client secret. The service handles a presented credential to authenticate a request but stores its hash rather than the credential. Consent requests expire after ten minutes and single-use authorization codes after sixty seconds. Access tokens last an hour. Refresh tokens rotate when used and expire after thirty days of inactivity; the authorization lasts at most ninety days. The service also keeps rate counters under keyed hashes of request IP addresses rather than the addresses themselves. Request-triggered cleanup removes expired requests and codes a day after their expiry, revoked authorizations a day after revocation, authorizations after their maximum lifetime, and rate counters older than two days. If there are no requests, cleanup waits for the next request. These are connection records, separate from saved-capture retention.

  • Ending a connection. An app can call the OAuth revocation endpoint to revoke its authorization. Revocation prevents new authenticated plugin reads. Where enabled, the dashboard's Connected apps settings also let you revoke an account's authorization. Signing out of the dashboard ends that browser session; it does not revoke an app you previously approved. Removing the integration in an AI host does not guarantee that this endpoint was called; check the host's disconnect behavior. A signed download link issued before revocation can remain usable until its short expiry. Revocation or deletion in Lil Labr does not delete copies already retained in a chat, image tool, prototype or Figma file. For questions, use the contact address below.

  • Other providers. The AI host and separately connected creative, coding or Figma tools handle the content under their own terms and privacy policies. Lil Labr supplies saved reference material; image generation, prototype execution and writing a Figma file require those separate tools. Hosting infrastructure and the AI host may keep request or download information under their own logging practices.

What the Figma plugin does

When you choose a local .labr file, Lillabr Import reads it in the plugin panel, checks and prepares its contents, and passes the selected capture to the plugin's Figma sandbox to create editable layers. The current plugin code does not send the chosen local file to Lillabr's sync service. The capture can contain the page data described below; after import, the resulting layers are part of your Figma file. The plugin does not upload existing Figma layers to Lillabr's service.

The plugin’s synced capture list is available only after pairing. Fresh pairing sends the code to the default developer-operated Lillabr service and receives a device token for that workspace. It stores the endpoint, token, and workspace ID in Figma's figma.clientStorage on your machine, not in the Figma document. This storage is specific to the plugin ID but is not a secure vault; someone with access to your device may be able to inspect it. While a paired plugin panel is open, it requests the capture list when opened and refreshes it about every five seconds while visible. The list includes capture titles, sanitized page addresses, thumbnails, and flow grouping. It downloads a complete archive when you choose a capture to import. The service operator can read archives held on that service, as described in Send to Figma (sync).

An existing saved plugin connection can retain a previously configured Supabase endpoint or http://localhost:8931 until you choose Disconnect. The current UI provides no setup control for another endpoint. Listing, downloading and deleting captures on a retained connection use that saved service. A localhost connection can use unencrypted HTTP over loopback on your computer. The default service uses HTTPS; another service's operator, storage and retention practices may differ. The seven-day expiry and newest-50 limit described below apply to the default Lillabr service.

The plugin does not keep a separate persistent copy of opened or downloaded archives in its own client storage. It holds them during the open plugin session and sends the selected content to Figma to build layers. Figma's own file storage and retention apply to those imported layers.

The plugin stores its voluntary review reminder record in local Figma clientStorage. It contains a successful file-import count, the highest reminder milestone handled, the time until which Later keeps the reminder away, a listing-open reminder suppression time, and at most 32 recent random import operation IDs for deduplication—not file names, page URLs or captured content. Only successfully committed imports of verified .labr files count; completed files within a flow may count separately. Automatic reminders use successful file-import milestones of 5, 15, 30, 50 and 100, independently of Chrome captures and analytics. The reminder card has no close control. Later dismisses the current milestone and also keeps the reminder away for 30 days, even if the next milestone is reached sooner. Choosing Later at the 100-import reminder ends automatic requests. Missed milestones collapse to the highest reached milestone. Opening the official listing pauses automatic reminders for 90 days. Since version 1.0.6 of the plugin the reminder card is its only way to the listing: Settings and Contact no longer show a review link (earlier versions showed one after five successful imports). Lillabr does not observe whether a review was submitted, and it sends no review record to a review server.

The plugin also keeps a small first-run record in the same local Figma clientStorage: the time you pressed Install or said you had installed the Chrome extension (or connected with a code, which shows it is installed), the time you finished or skipped the first-run screens, and whether the optional experience survey is over. It holds no answers, scores, pairing codes or capture details, and nothing in it is sent anywhere.

What is inside a snapshot file

If you keep a .labr file, its verified ZIP contains the editable scene and capture report. A capture can hold:

  • A manifest page address with credentials, query string, and # fragment removed. So https://example.com/pricing?token=abc#plans is recorded as https://example.com/pricing.

  • The page title and the time you captured it.

  • The size of your browser window and your screen's pixel ratio.

  • Your browser's user agent string, which says which browser and operating system version made the capture.

  • The layers themselves: geometry, colours, text content, font names, and the bytes of each image or SVG that Lillabr successfully captured. Blocked, oversized, empty, or unsupported assets can instead produce a warning or placeholder.

  • A capture mode and, for a picked element, a CSS path to that element.

The editable scene and visible page content may still contain outbound links with query strings, visibly rendered codes, private dashboard data, communications, and other text. Lillabr does not yet provide a complete redaction/review step. Sanitizing the manifest URL does not make an archive safe to share.

Password inputs and payment card inputs marked with autocomplete="cc-number", cc-csc, or cc-exp… are replaced with the same eight-bullet mask in the .labr/legacy scene and native-Figma route. In Chrome 1.0.1 and later, every populated text input, textarea, and select inside an embedded frame is masked, even when the page omits card metadata. The original value and its length are not stored in the editable scene or direct Figma paste. In Chrome 1.0.6 and later the thumbnail, and the picture the panel keeps of a capture, are drawn from that same editable scene, so these values are masked in them too; the thumbnail is uploaded when Cloud sync is on. Thumbnails uploaded by earlier versions are screenshots of the tab and can show such values as pixels where they were visible on screen. Other visible form values outside embedded frames may be kept; an unmarked top-level card input cannot be reliably identified as a card field. Treat the local cache, clipboard and saved files as sensitive as the page being captured. The current Chrome panel has no supported HTML-export control.

Send to Figma (sync)

Cloud uploads are off before first use. In a new installation, agreeing to this policy and the Terms of Use on the first capture step (ticking the box and pressing Capture full page) turns them on, with the Settings switch Save captures; captures then sync until you turn Save captures off. Captures go to a sync service the Lillabr developer operates, hosted on Supabase at https://api.lillabr.com/functions/v1/sync. The developer can read every capture you sync. HTTPS protects the transfer to this service; the archives are not end-to-end encrypted by Lillabr, so the service operator can read their contents.

If that is not acceptable for a page, turn Save captures off before capturing it. Then use direct paste or Download capture and open that file in the plugin by hand. The saved local file is not uploaded by that file handoff. A plugin that was paired earlier can still request its cloud capture list while open until you disconnect it. New connections use the developer-operated service; an older saved plugin connection can continue using its retained endpoint as described above. An existing explicit Off preference survives the agreement on the capture step and pairing. A legacy destination changes only after you accept the new practices; earlier local captures are not uploaded automatically, and remote copies at an earlier destination are neither transferred nor deleted. Page asset and font requests described below may still leave your computer during capture.

When Cloud sync is On, Lillabr attempts to upload each future successful capture. A failed upload leaves its local archive available. Uploads include:

  • The complete .labr archive. That is the whole capture — every image and SVG it collected, all visible text, captured form values, and the page title and address. It is not end-to-end encrypted by Lillabr, so the operator of that service, its backups, and anyone who compromises it can read the captured page.

  • A thumbnail of the capture is uploaded with it. A small WebP or JPEG image, 320 pixels wide, so the plugin's list is browsable. In Chrome 1.0.6 and later it is drawn from the capture itself (the top of the page as the capture holds it, with masked form values masked), so it shows nothing the archive does not already hold, and a capture whose thumbnail could not be drawn in time is uploaded without one. Earlier versions uploaded a screenshot of the visible tab, which showed whatever was on screen, including original form pixels the editable scene masks.

  • A short description is uploaded with it so the plugin can list it: title, the already-sanitized page address, capture mode, viewport size, and layer, text, image and SVG counts.

  • Which flow it belongs to. Captures are grouped into a session — a walkthrough of several pages, so they can be imported together in order. The service stores that grouping, its position in the flow, and the flow's label.

  • An archive over 50 MB is not uploaded. The panel says so and the capture stays local.

Pairing uses a code; an account is optional. In Chrome 1.0.4 and earlier, and in Chrome 1.0.6 until you sign in, a workspace has no email address, password, or profile: it is a random id and the device tokens that belong to it. From Chrome 1.0.6 you can sign in with Google, which links your workspace to an account (see Signing in with Google below); the Figma plugin still pairs with a code and never signs in. Agreeing on the capture step saves the acceptance and the Save captures choice locally; it does not itself register a workspace or upload a capture made before it. The extension registers a workspace when a subsequent capture needs an upload, when you explicitly request a pairing code, when you later turn Cloud sync on in Settings, or, from Chrome 1.0.6, when you sign in with Google and have no connection yet (Cloud sync stays Off if you had chosen Off). It holds a random device token in extension-local storage. Paste the eight-character, one-time code shown in Chrome into Lillabr Import to connect the plugin, which then receives its own token. The Figma card, on the panel's Capture tab (under Finish setup until setup is done) or in Settings, makes a fresh code when you ask for one (opening the card yourself, Show setup code, or, once Figma is connected, Get a new setup code under Manage on the card in Settings), and shows how long it is still valid. Opening the panel alone does not register. Requesting a code while Cloud sync is Off preserves that choice. The code works once and expires in ten minutes. From Chrome 1.0.6, while the card shows a code it asks the service whether the Figma plugin has claimed it, and says Connected by itself once it has (see The Chrome extension's outgoing requests, kind 3); where the service cannot answer that question, the card asks you to confirm instead (I see it in Figma). Anyone who obtains a device token can read that workspace’s captures until it is revoked.

On the default Lillabr service, synced captures expire after seven days. That service deletes expired archives and metadata when it next handles a sync request, so they may remain stored longer if no request arrives. It keeps only the newest 50 per workspace. Clear Chrome connection in the panel's Settings, or Disconnect in the plugin, attempts to revoke that device's token on the server and clears its local pairing settings even when the server cannot be reached. If revocation fails, the server token may remain valid. Disconnect does not delete captures already uploaded. The current plugin has Delete controls for listed synced pages and Delete flow for an entire listed flow. Each asks for confirmation, then sends an authenticated deletion request to the paired sync service: the default Lillabr service or an older retained endpoint. After a success response, the plugin refreshes the list. It reports a failed request so you can retry, or a failed list refresh so you can wait for the automatic retry to check the result. From Chrome 1.0.6 the panel's Recent tab also has Remove beside each page of the current flow: after you confirm, Chrome sends the same authenticated deletion request for that page, which removes it for the whole workspace (the plugin stops listing it), and takes it off the panel's list. Download all N pages in the same tab lists the current flow on the service, downloads each of its pages (each checked against its length and SHA-256) and saves them in your Downloads folder as one .labr file that the plugin's Import a file can open; the pages are held in memory only until that file is written. Deleting a synced page or flow does not delete a .labr file you saved or layers you already imported into Figma. The .labr file you save yourself remains the durable copy; sync is a transport, not a backup.

Signing in with Google

The web dashboard, where enabled. https://app.lillabr.com uses the same Google account identity as Chrome. Google handles sign-in and gives the server a one-time code. The server exchanges and validates it using openid, email and profile; frontend JavaScript receives no Google token, Google password, Chrome device credential or Supabase service credential. Signing in through the dashboard preserves your existing account, owned capture workspace and product-news choice. It does not create a second capture workspace. A new account must link its captures through a compatible Chrome install before they appear in the dashboard or can be authorized for an AI app. Chrome 1.0.9 and later can complete this account setup through the handoff described below.

The dashboard uses a required, first-party __Host-lillabr-session cookie to keep you signed in for up to 90 days. It is Secure, HttpOnly, SameSite=Lax and limited to the app host; the service stores only a one-way hash with the account, creation, expiry and revocation dates. A separate __Host-lillabr-login cookie binds a sign-in attempt to the browser and lasts ten minutes. The service keeps its hashed browser/state references, nonce, code verifier, safe return page and expiry until request-triggered cleanup removes expired attempts a day later. It does not retain the Google code or tokens after the exchange. Dashboard API responses are not cached and share no cookies with the marketing website.

Connecting the dashboard and Chrome (1.0.9 and later). A compatible Chrome install can use your signed-in dashboard session to connect the same account, and signed-in Chrome can restore that account's dashboard session. The service checks the current account and workspace ownership; different accounts are not silently switched. Chrome's device credential stays inside the extension's worker, and dashboard session credentials stay in HttpOnly cookies. A handoff uses a single-use reference lasting at most two minutes, a worker-held code verifier or a host-only __Host-lillabr-handoff cookie, and server-side account, session and hashed proof references. Expired handoff records are removed by request-triggered cleanup after a day; with no requests, cleanup waits.

The required, Secure, HttpOnly, SameSite=Lax __Host-lillabr-signin-intent cookie lasts two minutes after successful Google sign-in. The equivalent __Host-lillabr-signout cookie can remember an explicit dashboard sign-out for up to 90 days so Chrome does not automatically sign that browser back in. Chrome remembers its own explicit sign-out privately as well. These handoffs do not accept capture terms, complete Figma onboarding, turn on capture saving, or add an AI app's capture permissions. Saving and connection consent remain your choices. Older or unavailable Chrome installs can use Google sign-in in the dashboard directly.

Settings lets you change the product-news choice, sign out, revoke browser sessions, and revoke connected AI apps. Session revocation prevents later use; request-triggered cleanup removes expired sessions and sessions revoked more than a day earlier. With no requests, cleanup waits until the next request. Required session cookies serve sign-in, not advertising or analytics. Hosting providers process request information under their own logging practices, and the service uses keyed IP hashes for abuse limits as described below.

Chrome 1.0.6 and later. Signing in is optional, and no capture ever needs it, however many captures you make: you can always capture, copy or save captures, open files and use Settings without it. What it gives you is below (Why sign in), and you need it to use Claude or ChatGPT with Lillabr (see The optional AI connector link). Chrome 1.0.4 and earlier have no sign-in. Nothing in this section happens until Lillabr turns sign-in on at its server: the extension asks (see The Chrome extension's outgoing requests, kind 6), and until the answer is yes there is no sign-in button and no account. Lillabr can turn sign-in off again at any time, and nothing is deleted when it does: the extension stops offering it (so someone who is not signed in cannot set up Claude or ChatGPT meanwhile). It also stops offering it if it cannot get an answer from Lillabr's server for 24 hours.

  • Why sign in. First, to keep your progress. Signing in links your Cloud sync workspace to your account, so another browser, or this one after you reinstall, can sign in and reach the same workspace, and the Figma plugin, which pairs with a code, sees it too. Captures still expire after seven days: signing in restores your workspace, not captures that have already expired. Second, to give Lillabr an email address, which it uses to run your account and Cloud sync and to email you (see Email below).

  • The sign-in itself. Sign in with Google opens Google's own sign-in window in Chrome and asks Google only for openid, email and profile. Google handles your password and any 2-step check under Google's privacy policy, and learns that you are signing in to Lillabr. Google gives Chrome a one-time code. Chrome sends it to Lillabr's account service, which trades it with Google using a secret that only that service holds, and learns your Google account ID, your email address (which Google has verified) and your name. Lillabr uses that reply once. It keeps no Google token, no password and no profile picture, and a web page never sees the code or any Google token.

  • What Lillabr stores for your account. On the developer-operated service, in the same Supabase project and US East database as Cloud sync: your Google account ID, email address, the name Google gives, your product-news choice (yes or no) and when it was recorded, when the account was made and last signed in, and which Cloud sync workspace is yours. If Cloud sync is already connected in your Chrome when you sign in, Chrome sends its device token along with the code, so that Lillabr links that workspace to your account instead of making another; as with Cloud sync, the service stores only a hash of a token. To limit abuse the service counts sign-in attempts under a keyed hash of the network address (not the address itself) for up to two days. Its own logs name the kind of failure, never an email address, a code, a token or a secret. The developer can read the account records.

  • What Chrome keeps. In chrome.storage.local, which web pages cannot read and Chrome Sync does not copy. While you are signed in: your email address, name, the time you signed in and the account's product-news choice as the server last said it. Until your first sign-in on that browser takes it to Lillabr's server: your answer to the product-news box on the capture step (yes or no, and when). Always: whether and when you agreed to this policy and the Terms of Use (the version of the terms, and whether you agreed in the panel or on the welcome page, or were counted as agreeing by an update), whether a capture was copied for Figma (the first one, from any page) and whether you said, in the panel or on the welcome page, that you pasted your first capture in Figma (and when each happened), the times at which you finished or left the first-run steps and its optional survey, the times at which you marked steps of the Figma setup list in the panel as done or the Figma connection was confirmed by you or found by the panel (and which of the two it was), when the last setup code this Chrome made stops working (never the code), and the last answer from Lillabr's server about sign-in (on or off and the public Google client id) with the time it was fetched. It keeps no count of your captures for sign-in (the review reminders keep their own count, described in What the Chrome extension stores in the browser). Nothing about an account goes to analytics. Sign out removes the email address, name, product-news choice and any product-news answer still waiting to be sent, and keeps your agreement and the Cloud sync connection.

  • Email. Lillabr uses your email address for two kinds of email. Account and service email (about your account, Cloud sync or a change to this service) does not depend on any box. Product news is sent only if you ticked "Email me Lil Labr product news" on the first capture step, beside the agreement to this policy and the Terms of Use. That box starts unticked and nothing depends on it; it is not shown again once you have agreed. Your answer is sent once, with your first sign-in on that browser, and then deleted from the browser: a later sign-in, of your account or of anyone else on the same browser, sends no choice and leaves the account's as it is. To stop product news, use the unsubscribe link that every product-news email will carry, or write to the contact address below; neither affects your account or Cloud sync. As of 8 October 2026 Lillabr has sent no email through this feature. Sending needs an email service that acts only for Lillabr, and this policy will name that service before the first email is sent.

  • Who else sees your account data. Google, for the sign-in itself. Vercel, which hosts the website, dashboard and first-party request routing described above. Supabase, which hosts the account service and its database for Lillabr. An email service, once Lillabr has chosen one and named it here. Lillabr does not sell your email address or name, does not give them to advertisers or data brokers and does not use them for advertising. The Limited Use rules above apply to all of it.

  • The welcome page and the install tab. When Chrome 1.0.6 or later is newly installed, it opens https://lillabr.com/welcome/ in a new tab, once. It does not open on an update, you can close it, and nothing depends on it. It is a page of Lillabr's own website that loads only files from lillabr.com; like any website, its host can see the page request and the requesting IP address. The page shows how to capture a page with Lillabr and paste it into Figma, one step at a time, and has the Sign in with Google button. It talks to the extension through the externally_connectable setting in the extension's manifest, which lets only pages of https://lillabr.com/welcome message the extension, and the extension checks the sender again on every message. The page can ask for these things only: how things stand; to record that you agreed to this policy and the Terms of Use, with your answer to the product-news box, when you tick the box on its capture step and press Capture full page (the same record as the panel's box); to capture the welcome page itself, when you press Capture full page there (the extension captures the page the request came from and copies it for you to paste in Figma, as if you had chosen that action in the panel; it is a capture like any other, and counts toward the review reminders like one); to open the Lillabr side panel for the page's own tab, as if you had chosen the toolbar icon there (it captures nothing; Chrome allows this only within your click, and otherwise the page asks you to click the toolbar icon; from the last first-run screen it also ends the first run); to record that you said you pasted your first capture in Figma; to record that you chose Not now on the sign-in step; to leave the first-run steps (Start capturing, or leaving early); to send the three answers of the optional feedback questions, and to close them, answered or not (after the review request that follows three scores of 5, with which of its two buttons you chose; see Feedback after your first capture); to start a sign-in; and to sign out. It is told whether the extension is installed, its version number, whether you have agreed to this policy and the Terms of Use, whether a capture was copied for Figma (and, if a try failed, only which of two fixed reasons: the box was not ticked, or the capture failed), whether you said you pasted a capture, which first-run step you are on and whether the first run is over, whether the feedback questions may be shown, whether answers were already sent and, until the questions are closed, which of their two last screens the answers led to (the review request or the thank-you), whether sign-in is available, how an attempt is going and whether you are signed in, but not who: it is never given your email address or name, a Google code or token, a Cloud sync token or workspace id, a capture or a page address. Your email address is therefore never drawn on the page, and cannot end up in a capture of it. The page stores nothing about you in your browser and sends nothing it learns anywhere.

  • Signing out. Sign out in Settings (Account) or on the welcome page forgets your account in that browser, and so does Clear Chrome connection (the workspace your account was linked to is then no longer this browser's; signing in again brings it back). Signing out does not delete your account at Lillabr's service, disconnect Cloud sync or delete captures, and you can go on capturing as before. It is available whenever you are signed in, also when sign-in has been switched off or cannot be reached.

  • Deleting your account. For now, by email: write to the contact address below from the address on the account. Lillabr then deletes the account record (Google account ID, email address, name and product-news choice). Answers to the feedback questions are not linked to an account, so they are not part of it. Your workspace is then linked to nobody, and its captures expire as usual within seven days. Deleting the account does not by itself disconnect Cloud sync in your browsers: ask for that in the same email, or use Clear Chrome connection in Chrome and Disconnect in the plugin (see Removing your data). Do not send a device token in an email. Google keeps its own record that you signed in to Lillabr, which you can review in your Google Account's settings.

Usage analytics

Lillabr uses PostHog US Cloud to measure the use and reliability of its capture, copy, save, sync, and import features. In Chrome 1.0.6 and the current Figma plugin, usage analytics is on by default, and neither the Chrome panel nor the plugin has a switch for it.

  • Chrome, a new installation: analytics starts when you tick "I agree to the Privacy Policy and Terms" on the first capture step and press Capture full page, in the panel or on the welcome page. Nothing is sent before that.
  • Chrome, updated from an earlier version: it keeps exactly the choice it had. Analytics that was off, or never turned on, stays off; an explicit "off" is never overridden.
  • The Figma plugin: analytics is on unless you turned it off in an earlier version; then it stays off, and its Settings say that usage data sharing is off on this computer.

To object, write to the contact address below. Removing the extension or the plugin also stops it. You can keep using both products whatever you decide.

While it is on, Lillabr sends explicit events to https://us.i.posthog.com/i/v0/e/ over HTTPS. These may include opening the plugin or the panel, starting and finishing a capture or import, success or failure of a copy, save, pairing, or sync upload, and importing a flow. Events contain only a fixed action name, timestamp, product surface, version, capture mode or import source, coarse outcome, bounded counts or duration, and relevant boolean import options.

Analytics never includes captured text, images, archives, thumbnails, page URLs or titles, filenames, raw error messages, browsing history, keystrokes, CSS selectors, Figma file or node IDs, sync workspace/capture IDs, device tokens, or pairing codes. Lillabr loads no remote analytics code and does not use autocapture, pageviews, session replay, or automatic exception reporting.

When analytics starts, Lillabr creates a random pseudonymous analytics ID and stores it with the preference in extension-local storage or Figma's plugin clientStorage. It is separate from all Figma and sync identities, is not shared through Chrome Sync, and is not linked across the extension and plugin. PostHog receives that ID so repeated events from the same installation can be counted. The event payload suppresses person-profile processing and geographic enrichment and substitutes a non-user IP value. As with any outgoing request, PostHog's network infrastructure can observe the requesting IP address. This is pseudonymous usage measurement, not a claim of anonymous processing.

The Lillabr developer can access these events in PostHog. They are used to understand and improve Lillabr's functionality and reliability, not for advertising, unrelated profiling, or sale. PostHog processes them on the developer's behalf. See PostHog's privacy policy.

An installation whose analytics is off sends no analytics requests and keeps no analytics ID. Events PostHog already received remain subject to the project's retention settings and deletion by the operator; Lillabr does not promise a fixed analytics retention period in this version. Contact the developer below for privacy questions or an objection. The Chrome extension and the Figma plugin each keep their own analytics preference and ID: removing one does not change the other.

Feedback after your first capture

Chrome 1.0.6 and later. After your first capture and "I've pasted it in Figma", the panel or the welcome page can ask three short questions about how it went: a score from 1 to 5 for each and, for a score below 5, a few words about what could be better (500 characters at most). They are shown only while Lillabr has switched feedback on at its account service (it is off until Lillabr turns it on), so the screen after the third question means your answers can be kept. Lillabr can switch them off again at any time: they are then not shown, an answer that arrives anyway is not kept, and answers already kept stay until they are 12 months old. Skip feedback sends nothing, earlier answers included, and the questions are not asked again either way.

In the Chrome panel and on the welcome page, the screen after the third question depends on your scores. After three scores of 5 it asks you to review Lillabr on the Chrome Web Store: Review on Chrome Web Store opens the store's listing in a new tab, and Not now goes on without it. After any lower score it thanks you instead and does not ask. The button you choose on that request counts as your answer to the review reminder at 5 captures, and it is kept with the review reminders (see Disclosure and review reminder state). Lillabr cannot see whether you wrote a review, or what it said.

  • What is sent. Continue on the third question sends the answers once, over HTTPS, to Lillabr's account service at https://api.lillabr.com/functions/v1/account (POST /v1/feedback): the three scores, the reasons, where you answered (the Chrome panel or the welcome page) and the extension's version. Nothing else: no cookie, account, email address, capture, page address, analytics ID or Save captures token.
  • What is kept. Exactly that, with the day it arrived (not the time), on the developer-operated service in the same Supabase project and US East database as Cloud sync. Never your account, workspace, email address or IP address: the service has no place to store them with an answer. To limit abuse it counts these requests under a keyed hash of the network address (not the address itself), kept up to two days, as for sign-in. Answers are kept 12 months and then deleted. Please do not put personal information in the reasons.
  • Who sees them. The developer, who uses them only to improve Lillabr. Vercel routes the requests, and Supabase hosts the answers for Lillabr. They are not sold, not used for advertising and not linked to your analytics events.
  • What Chrome keeps. That answers were sent and when (never the answers), so they are not sent twice; until you close the questions, which of their two last screens the answers led to (the review request, which says that all three scores were 5, or the thank-you), so that the panel and the welcome page show the same one, removed once the questions are closed; and, in the account record, when the questions were over for this installation, answered or not. Your answer to the review request goes into the review reminder record (see Disclosure and review reminder state).
  • The Figma plugin. It has no place to send answers in this version, so it does not ask these questions.

Reporting a capture (Chrome 1.0.6 and later). Under the latest capture in the panel, and under the picture of a capture you open from its thumbnail, Something didn’t come through? opens a short report about that capture, for when something on the page is missing from it. Opening it sends nothing about the capture or about you (the panel only asks Lillabr's account service whether it takes reports, as described below).

  • What you choose. Nine boxes for what is missing (images; text or fonts; icons or vectors; layout or spacing; colours; shadows or effects; video; canvas or embedded frames; something else), an optional note of at most 500 characters, and the box "Include the page’s address (without anything after ? or #)", which is ticked when the report opens. Under What we send the panel shows the whole report, exactly as it would be sent or saved.
  • What a report holds. The boxes you ticked. Your note, in which email addresses, web addresses and runs of seven or more digits are replaced by "[email removed]", "[link removed]" and "[number removed]" before you see it under What we send (please do not put personal information in it). The page's origin and path, only if that box is ticked, cut before any part of the path that holds an @ (a handle or an email address can name a person). The extension's version with a short build fingerprint, the versions of its converters, Chrome's major version and the operating-system family (macOS, Windows, ChromeOS, Android, Linux or other). And counts and codes about the capture, which the extension works out on your computer when the capture is made and keeps with its picture (see What the Chrome extension stores in the browser): the capture mode, the window and page size and the screen's pixel ratio, how long each phase took, whether the capture was copied and whether its Figma import would be blocked, counts of layers, text characters, images, frames and other kinds of element, how many elements use certain CSS features, the names of the fonts the page asked for and whether they loaded, the codes of the capture's warnings, each with the names of up to five websites its message mentions, and, for each file that failed to load, its kind, the reason, its file extension and the name of the website it came from. The page's own website is written only as "page-host" or "page-site", an IP address as "ip-address" and a machine on a local network as "local-network"; other websites keep their names. When those details are no longer on your computer, the report holds only your choices and the versions.
  • What a report never holds. Page text, the page title, form values, images, full file addresses, anything after ? or # in an address, cookies or other browser storage, your email address, your account, workspace or device id, your IP address or the browser's user agent. The extension checks a report before it sends it and refuses one that holds anything shaped like these, and the service checks it again before it keeps it.
  • Where it goes, and when. Only when you press Send report: one request over HTTPS to Lillabr's account service at https://api.lillabr.com/functions/v1/account (POST /v1/reports), with the report and nothing else: no cookie, referrer, token or identifier. Send report is offered only while Lillabr has switched reports on at that service, which the panel asks when you open a report. Reports are off until Lillabr turns them on, and Lillabr can turn them off again at any time.
  • What is kept, and for how long. The report as it arrived, the extension version and the ticked boxes, with the day it arrived (not the time), on the developer-operated service in the same Supabase project and US East database as Cloud sync. Nothing is added that says who sent it: the service has no place to store an account, workspace, device, email address or IP address with a report. To limit abuse it counts reports under a keyed hash of the network address (not the address itself), at most 30 an hour from one network, kept up to two days as for sign-in. The service's own log names only the boxes that were ticked. Reports are kept 90 days and then deleted.
  • Who sees them. The developer, who uses them only to find and fix what captures miss. Vercel routes the requests, and Supabase hosts the reports for Lillabr. They are not sold, not used for advertising and not linked to your analytics events; nothing about a report goes to usage analytics.
  • While reports are off. The panel offers Download report, which saves the same report as a .json file in your Downloads folder, and Email it, which opens your email app with a new message to the support address, with a fixed subject and a fixed text and nothing from the page; you attach the file yourself if you want to send it, and your email provider handles that email. A report that could not be sent (reports switched off meanwhile, too many from your network, or the service out of reach) is offered the same way; one that the extension or the service refuses as it stands is neither sent nor offered as a file.

The Chrome extension's outgoing requests

The extension makes four kinds of request to the internet, a fifth only if you create an AI connector link (Chrome 1.0.6 and later), a sixth and a seventh from Chrome 1.0.6, plus the local connection described in The optional AI assistant link, which never leaves your computer. Only the third and fifth kinds send a complete capture archive or thumbnail; the third's uploads occur while Save captures (Cloud sync) is On after you have agreed on the capture step. The same service can also receive explicit pairing and listing requests while uploads are Off. The fourth goes to PostHog while usage analytics is on (see Usage analytics). The fifth sends the captures that AI apps ask for and you allow, to a separate Lillabr service. The sixth asks Lillabr's account service whether sign-in, the feedback questions and capture reports are on, takes part in a sign-in only if you sign in, carries the answers to the feedback questions only if you answer them and a capture report only if you press Send report; it never carries a capture. The seventh reads a public file of announcements from Lillabr's website and sends nothing about you. The paired Figma plugin’s sync requests are described in What the Figma plugin does.

1. The page's own assets. Chrome grants Lillabr <all_urls> host access so it can inject capture code into the user-selected active tab and re-fetch page-declared resources. Same-origin re-fetches run in the page and use credentials: 'same-origin', so they may include that site's existing cookies. The content-script path bounds same-origin fetches and local data: decoding to 15 seconds and 20 MB. When a same-origin read is unavailable, the background relay can fetch cross-origin HTTP/HTTPS assets with credentials: 'omit'. That relay uses the browser's cache first and drops anything over 20 MB. Its caller can supply the remaining asset deadline, which the worker clamps to 1–20,000 milliseconds and reports back; the default is 20 seconds. data: resources are decoded locally and do not make a request. A file: address is fetched only when the captured page is itself an enabled local file: page, so a website cannot use Lillabr to read arbitrary files off your disk. Resource hosts can observe the requested URL and IP address.

  1. Font files from cdn.jsdelivr.net. Lillabr enables native-Figma conversion for each capture. Figma needs the real font file to measure text the same way your browser did, so Lillabr downloads the matching font from Fontsource's copies of the open source fonts on jsDelivr. The address looks like https://cdn.jsdelivr.net/fontsource/fonts/inter@5/latin-400-normal.woff2. It contains a font family name, a weight and whether it is italic. It carries no page address, no page content, and nothing about you. If a family is not on Fontsource, Lillabr falls back to Inter. jsDelivr is a public content delivery network run by a third party, and like any web server it can see the requesting IP address and the file requested. Lillabr has no setting that disables these requests while retaining native-Figma conversion. Opening an already saved .labr file in the Lillabr Import plugin does not contact jsDelivr.

  2. The sync service, while Cloud uploads (Save captures) is on. The uploads described above go only to the developer-operated service. Agreeing on the capture step itself saves local state only. After that, Lillabr can register when a future upload, explicit pairing-code request or later Save captures On action needs a workspace. It also contacts the service to mint a requested pairing code, start or list a flow, and upload a finished capture. From Chrome 1.0.6 it also asks the service whether a Figma plugin has claimed one of your workspace's pairing codes (GET /v1/status), so that the Figma card can say Connected by itself: while a setup code is shown in an open panel, every 3 seconds for the first minute, then every 5 seconds, then every 10 (at most 86 times for one code, including once more the moment it expires; a panel hidden behind another tab stops asking after 30 seconds until it is shown again), and once when a panel is opened while Figma is not connected and it is not yet known whether a code this Chrome made was claimed (no more than once every 30 seconds, and no later than a day after that code expired). The question carries this installation's device token and nothing else, the answer is only yes or no, and the service only reads its records to answer it and writes nothing. An installation that never made a setup code never asks it, and a version of the service that does not know the question makes the card ask you to confirm the connection instead. Also from Chrome 1.0.6, and only when you press them in the panel's Recent tab, Remove sends the deletion request for that page and Download all N pages lists the current flow and downloads each of its pages (see Send to Figma (sync)). Pairing, listing, status, removal and download requests can occur while uploads are Off; they do not upload a capture or turn uploads on. Its uploads go straight to the storage bucket through a single-use signed URL the service mints for that one capture.

4. PostHog, while usage analytics is on. In a new installation, from your agreement on the capture step; in an updated one, only if analytics was already on. The limited workflow events described above. No capture content is included, and analytics failures do not block capture or import. Lillabr does not queue analytics offline or retry it.

5. The AI connector service, only if you created a connector link (Chrome 1.0.6 and later). Requests over HTTPS to https://api.lillabr.com/functions/v1/connector to create, pause, reset or turn off the link, delete its captures, ask how many it holds, and handle each request an AI app makes (accept it, report its progress, ask for an upload address and report the result); one secure WebSocket (wss) connection to the same service while the link is on and not paused; and, for each capture, one upload of the encrypted capture to Supabase Storage through a single-use address the service gives Chrome for that capture. What they carry is listed in The optional AI connector link. They carry no cookies, and neither your analytics ID nor Cloud sync's tokens.

6. The account service (Chrome 1.0.6 and later). Requests over HTTPS to https://api.lillabr.com/functions/v1/account, the service described in Signing in with Google and Feedback after your first capture (with Reporting a capture). Every Chrome 1.0.6 asks it, whether or not you ever sign in, whether sign-in and the feedback questions are on: each time Lillabr's background worker starts (Chrome stops the worker when it has had nothing to do for about 30 seconds and starts it again when it is needed, so this does not wait for an hour, whatever the last answer was), and otherwise when the panel or the welcome page needs the answer or you press Sign in with Google and the last answer is more than an hour old. A capture never waits for it. While the service does not answer, it is asked again at each start of the worker, at most about once a minute when you open the welcome page (and whenever you press Sign in with Google), and otherwise at most about once every ten minutes. That request carries no identifier, capture, cookie or account data; like any request it shows Chrome's ordinary headers and your IP address to the service and to Supabase's network. The answer says whether sign-in is on, the public Google client id, whether the feedback questions are on and whether capture reports are taken (it also carries a number of free captures, which the extension does not use or keep). When you open a capture report the panel asks the same question once more (after a yes, not again for ten minutes), to know whether it can offer Send report. Only if you answer the feedback questions: one request (POST /v1/feedback) with the three scores, the reasons, where you answered and the extension's version, as described in Feedback after your first capture. Only if you press Send report: one request (POST /v1/reports) with the report shown under What we send, as described in Reporting a capture, at the end of Feedback after your first capture. Only if you press Sign in with Google: Chrome opens Google's window at accounts.google.com, where Google's own policy applies, and then sends the one-time code Google gave it, the proof that goes with it, your answer to the product-news box (with the first sign-in on that browser only, see Email below) and, if Cloud sync is connected, its device token. The answer carries your email address, name and workspace and, only when a new Cloud sync connection is made for you, a new device token. These requests carry no cookies and neither your analytics ID nor any capture. Opening the welcome page is an ordinary request to lillabr.com.

7. Announcements from Lillabr's website (Chrome 1.0.6 and later). A request over HTTPS for one public file, https://lillabr.com/announcements/v1.json, which is the same for everyone. Chrome asks for it when it starts, when Lillabr is installed or updated and when you open the panel (none of these more than once every five minutes), and otherwise about every 30 minutes; Lillabr sets that interval in the file, between 15 minutes and once a day. Only when the file names a picture for the toolbar icon does Chrome also download that picture from https://lillabr.com/announcements/icons/, and it keeps a copy rather than downloading it again. These requests carry no cookie, referrer, identifier, version number or capture, and nothing about you or the pages you visit; like any request they show Chrome's ordinary headers and your IP address to the website's host. The file can change the toolbar icon, a small badge on it and its hover text, and show a short What's new card in the panel with a link that opens only if you choose it. The extension accepts only plain text, pictures from lillabr.com and links to lillabr.com, the Chrome Web Store and figma.com; a file with anything else in their place is ignored. Nothing in it can start a capture, change a setting or run code, and nothing is shown before you have agreed on the capture step or during the first-run steps.

Lillabr has no automatic error reporting service (a capture report goes only when you press Send report) and no update ping beyond Chrome's own extension updates and, from Chrome 1.0.6, the sign-in, feedback and reports check in kind 6 and the announcements check in kind 7. With sync off and no connector link, captures are not uploaded to Lillabr's service, but a capture can still request page assets from their hosts and font files from jsDelivr as described above.

The demo banner and Google Calendar. The Chrome panel's Capture tab, the plugin's work area and the website's How it works page show a banner, "Get a 15-min demo", whose button Book a 15-min demo opens the developer's booking page on Google Calendar (calendar.google.com), where you can book a 15-minute demo. In the Chrome panel and on the How it works page the button opens a dialog that shows Google's booking page in a frame. The frame is made only when you press the button and is removed when you close the dialog, so nothing is loaded from Google before you press it; then your browser requests the page from Google directly, without a referrer, and Google can see your IP address and the request, as with any website. Open in a new tab under the frame opens the same page in a tab; on the website, without its script, the button is that plain link. In the plugin the button opens the same page in your browser. Lillabr's software sends Google no data and no identifier, and Google's own privacy policy applies to that page and to anything you enter in it. If you book a demo, the booking and the details you enter in Google's form (such as your name and email address) reach the developer through Google Calendar, as with any booking page, and are used to arrange and hold the demo. The banner's close button (×) in the panel and in the plugin hides it until you open the panel or the plugin again; nothing is stored for it.

Links that open another site. The plugin's Contact tab has Get in touch: Message on LinkedIn opens the developer's LinkedIn profile at linkedin.com in your browser, where LinkedIn's own policy applies, and Send an email asks Figma to open a new message to the support address in your email app (the address is also shown, with a Copy button, for when no email app opens). A capture report's Email it in the Chrome panel opens such a message too, with a fixed subject and text (see Reporting a capture). Lillabr sends no data and no identifier when it shows these or when you use them: your browser or your email app opens them, and your email provider handles an email you send. The panel's and the plugin's other buttons that open lillabr.com, figma.com (or figma.new, Figma's address for a new design file, behind the words "Figma Design canvas" on the paste step of the panel and the welcome page) or the Chrome Web Store are the same kind of link.

What the Chrome extension stores in the browser

  • Usage analytics preference and ID. Whether analytics is on (and whether that came from your agreement on the capture step) and, only while it is on, a random analytics ID, in chrome.storage.local.

  • The AI link's pairing secrets and allowed websites. Only if you used the optional AI assistant link: a secret per approved local server and the addresses (origins) of the websites you allowed it to capture, in chrome.storage.local, not readable by web pages. Disconnect assistant removes both; Forget allowed websites removes the websites.

  • The AI connector link's secrets, websites and log. Only if you created a connector link (Chrome 1.0.6 and later), in chrome.storage.local, not readable by web pages: the link and Chrome's second secret, the service address, whether the link is paused, how many captures the service holds for it and when it was last used, a log of the last 20 requests (time, website name and outcome, never content), the websites you allowed for it (their addresses, each good for 24 hours), and which version of its disclosure you accepted. In chrome.storage.session, which Chrome wipes when it closes: the ids of requests handled in the last two hours, the request running now, and counters for limits and refusals. Anyone who can read your Chrome profile can read the link, so treat it like a password. Turn off removes the link, the log and the allowed websites (if Chrome cannot reach the service at that moment, it keeps only the second secret and the service address until it can delete the link there). Reset link replaces the link and clears the allowed websites. Forget allowed websites removes only the websites.

  • Your agreement and sign-in state (Chrome 1.0.6 and later). In chrome.storage.local, not readable by web pages and not in Chrome Sync: when you agreed to this policy and the Terms of Use, the version of the terms and where you agreed (or that an update counted you as agreeing); your answer to the product-news box until your first sign-in takes it to the server; the email address, name, sign-in time and the account's product-news choice while you are signed in; when a capture was copied for Figma (the first one, from any page) and whether you said that you pasted your first capture in Figma; when you finished or left the first-run steps and their optional survey; when you marked steps of the Figma setup list as done, and when the Figma connection was confirmed by you or found by the panel's question to the sync service, with which of the two it was; and when the last setup code this Chrome made stops working (times and that one word only, never the code); the last answer from the account service about sign-in; and, for a few minutes after a request to Lillabr's server failed, the time it failed, so that the extension does not ask again at once. In chrome.storage.session, which Chrome wipes when it closes: a marker that a sign-in window is open, and that failure time. Sign out removes the email address, name, product-news choice and any answer still waiting to be sent, and keeps the rest. See Signing in with Google.

  • Feedback (Chrome 1.0.6 and later). In chrome.storage.local: whether answers to the feedback questions were sent and when, never the answers, and, only until the questions are closed, whether the answers led to the review request (all three scores were 5) or to the thank-you. See Feedback after your first capture.

  • Announcements (Chrome 1.0.6 and later). In chrome.storage.local: the last valid announcements file with the times it was fetched and last checked, the ids of the last 50 announcements you have seen and of the last 50 you dismissed (so a dismissed one does not come back), and, only while an announcement uses a picture from lillabr.com, a copy of that picture, so the toolbar icon can be drawn again after a restart without downloading it again (or, if that picture could not be used, its address and when, so it is not downloaded again for a day). None of it is sent anywhere. Removing Lillabr deletes it.

  • Capture preferences. Keyboard shortcuts use the same supported capture handling as the panel. Chrome may synchronize certain non-content capture preferences and their migration version through your Google Account. These values do not include captures, URLs or page text; the developer cannot see them.

  • The last capture's status. The text shown in the panel, such as "Copied to clipboard", the file names that were saved, layer counts and any warnings, is kept in chrome.storage.session, which Chrome wipes when the browser closes. On older builds without session storage it falls back to local storage.

  • The latest capture for retry. Extension-origin IndexedDB stores one ready .labr archive and, when available, its exact native Figma clipboard HTML sibling. It can also hold one in-progress replacement during capture. The ready record expires lazily after 24 hours; an unfinished record expires after one hour. Lillabr removes expired and superseded records during later cache access. Forget latest capture removes the ready record immediately. Browser quota pressure or eviction can remove it earlier.

  • Pictures of recent captures and report details (Chrome 1.0.6 and later). In a second extension-origin IndexedDB database (lillabr-capture-views-v1), which no web page can read: for each of your 24 most recent captures, the picture drawn from the capture (a thumbnail and, when it could be drawn, a full view), its page title and address (origin and path, without credentials, query or fragment), its capture mode, and the details a report about it would carry (counts, codes, font names and the names of other websites; see Reporting a capture), with the page's origin and path for the report's address box. Each capture's records expire after 7 days (after a day for a capture made in an Incognito window) and are not used after that; expired records, and those of captures older than the 24 newest, are deleted each time a new capture's records are written. Forget latest capture deletes the latest capture's records at once, and removing Lillabr deletes them all. Nothing is kept here for a capture an AI app asked for. None of it is sent anywhere unless you send or save a report, and then only what the report shows.

The retry cache and the pictures can include visible website content and private page data. They are local and are not Chrome Sync storage. When Cloud sync is on, a separate copy of a future capture is uploaded as described above; earlier cached captures are not uploaded merely by agreeing on the capture step or turning Save captures on. The local cache is not separately encrypted by Lillabr and must not be treated as permanent storage. The .labr file you save is the user-owned durable copy.

  • Disclosure and review reminder state. Chrome stores the Save captures (Cloud uploads) choice, the full-capture disclosure version recorded with your agreement (or accepted in an earlier version), and its separate voluntary review reminder state locally. The review record keeps a count and deduplication IDs for verified usable captures, the highest reminder milestone handled, and a listing-open reminder suppression time. The review request that follows three scores of 5 in the first-run feedback questions (see Feedback after your first capture) is the same request, shown early: its answer is written here as the answer to the next reminder milestone (on a first run, the one at 5 captures), so Not now there means the next automatic request waits for 15 captures, and Review on Chrome Web Store does the same and also pauses reminders for 90 days. No score is written here, but a milestone handled before it was reached can only come from that request, so this record, which stays in your browser, can show that you gave three scores of 5. Automatic reminders use successful-capture milestones of 5, 15, 30, 50 and 100, independently of the Figma plugin’s file-import count and analytics. Choosing Not now (or pressing Escape) on the reminder dismisses the current milestone; in Chrome the next request waits for the next milestone without a time-based Later delay. Dismissing the 100-capture reminder ends automatic requests. Missed milestones collapse to the highest reached milestone. Opening the official Chrome Web Store listing pauses automatic reminders for 90 days. The voluntary review link remains available after five successful captures. This record is not sent to a review server, and Lillabr cannot observe whether a review was submitted.

Data Lillabr handles

Chrome's policy treats local processing and storage as handling user data. The exact categories depend on the page the user deliberately captures:

Category Local handling Developer-hosted sync, only when enabled
Website content and resources Yes, for the user-requested page; from Chrome 1.0.6 also a picture of each recent capture, drawn from it, kept in the browser, shown for up to 7 days and deleted at the next capture after that. Complete captured archive and thumbnail are uploaded by default.
Form data Visible values may be captured; passwords, identified card fields, and in Chrome 1.0.1 and later populated form controls inside embedded frames are masked in editable scene data and direct paste. In Chrome 1.0.6 and later the thumbnail and the kept picture are drawn from the masked scene and do not show them; thumbnails uploaded by earlier versions are screenshots and may. Unmarked top-level card fields may be captured. Captured scene values and the thumbnail drawn from them may be uploaded (from earlier versions, a screenshot thumbnail that may show masked values).
Personally identifiable, health, financial, or location information Possible when visibly present on the captured page. If you sign in (Chrome 1.0.6 and later), your email address and name. May be included in the archive or thumbnail. If you sign in, the account service stores your email address and name (see Signing in with Google).
Authentication information Password input values are masked; other visibly rendered account names or codes may be captured. Visible account names or codes may be included.
Personal communications and user-generated content Possible when visibly present on the captured page. May be included in the archive or thumbnail.
Web browsing activity Current captured page URL/title only; no browsing-history list. Captured page title and sanitized address are uploaded.
User activity Current rendered/scroll/form state may affect the capture. Usage analytics separately measures Lillabr feature actions and outcomes, never source-page clicks or keystrokes. The resulting page state may appear in the archive or thumbnail.

The default developer-operated sync service runs on Supabase, which stores and serves uploaded archives and related metadata.

Through the optional AI connector link (Chrome 1.0.6 and later), the same categories can be handled for a website you allow an AI app to capture: the capture (website content, visible form values and anything private that is visibly on the page), a preview screenshot, the title and address of each captured page, and the addresses the AI app asks Lillabr to capture (web browsing activity). They pass through Lillabr's cloud to the app and expire within a day, as described in The optional AI connector link. The link and Chrome's second secret are authentication information for that feature only. The connector does not read your browsing history: it handles only the addresses an AI app asks for.

Through optional Google sign-in (Chrome 1.0.6 and later), Lillabr handles personally identifiable information directly: your email address and name, and your Google account ID, which identifies your account. They are stored by the account service and, while you are signed in, in the extension's local storage; they are not part of any capture and do not go to analytics. Its only authentication information is the Cloud sync device tokens that already existed (the service stores a hash of each); it never receives your Google password or keeps a Google token. It keeps no count or record of your captures for sign-in, which no capture needs. It does not read your browsing history, and the check whether sign-in is on carries none of this. The full description is in Signing in with Google.

Through the optional feedback questions (Chrome 1.0.6 and later), Lillabr handles user-generated content directly: the three scores and the words you type for a score below 5 (500 characters at most each), with where you answered and the extension's version. They are kept by the account service for 12 months, never with your account, email address or IP address, and used only to improve Lillabr. In your browser, the three scores also decide whether a request for a Chrome Web Store review follows them (only after three scores of 5). The full description is in Feedback after your first capture.

Through capture reports (Chrome 1.0.6 and later), only when you press Send report, Lillabr handles user-generated content (the boxes you tick and your note of at most 500 characters, with email addresses, web addresses and long numbers removed), web browsing activity in a narrow form (the origin and path of the captured page, only if you leave its box ticked) and technical facts about the capture and your browser (versions, Chrome's major version, the operating-system family, counts and codes, the names of the fonts the page used and of the other websites whose files failed to load or that its warnings name). Reports are kept by the account service for 90 days, never with your account, email address, device or IP address, and used only to find and fix what captures miss. While reports are switched off Lillabr sends nothing; a saved report file reaches the developer only if you email it to the support address yourself. The full description is in Reporting a capture, at the end of Feedback after your first capture.

Lillabr does not inspect cookie values, local/session storage, request or response headers, saved passwords, or browser history. A same-origin asset re-fetch can nevertheless include the site's existing cookies as part of the browser request. Cross-origin relay requests omit credentials. Resource hosts and jsDelivr can observe the requesting IP address and requested URL; they do not receive the complete capture from Lillabr.

No selling or advertising

The developer receives captures sent to the default sync service and can read them. Supabase processes and stores those uploads for that service. Lillabr does not use captured content for advertising, creditworthiness, lending, or an unrelated purpose, and does not sell it. The same applies to captures that pass through the AI connector service (Chrome 1.0.6 and later): they are used only to deliver them to the AI app you connected and to keep the service running and safe. Capture reports (Chrome 1.0.6 and later) are used only to find and fix what captures miss, and are not sold or used for advertising.

Your email address and name (Chrome 1.0.6 and later, if you sign in) are used only to run your account and Cloud sync and to send the email described in Signing in with Google; product news only if you ticked its box. Lillabr does not sell them, does not transfer them to advertisers, data brokers or anyone else except as the Limited Use section allows, and does not use them for advertising, creditworthiness, lending or an unrelated purpose.

Children

Lillabr is a design tool and is not directed to children. It does not knowingly operate a child-focused service or collect account details from children; a user-requested capture is handled locally in the same way regardless of the content on the page.

Removing your data

The Chrome retry cache and Figma plugin pairing settings are stored on your device. Imported layers are part of your Figma file. Captures uploaded to the default Lillabr service are held by the developer-operated sync service. A retained older plugin connection lists, downloads and deletes captures on its saved service instead. To remove data:

  • Use Forget latest capture in the panel's Settings to remove the ready IndexedDB record, and with it (Chrome 1.0.6 and later) that capture's picture and report details. The pictures and report details of other recent captures are no longer shown after 7 days (a day for a capture made in an Incognito window) and are deleted at your next capture after that; removing Lillabr deletes them at once.

  • Neither the Chrome panel nor the Figma plugin has a switch for usage analytics. To object, write to the contact address below; removing the extension or the plugin stops its analytics and deletes its local analytics ID. Neither deletes past events already received by PostHog: ask for that in the same email.

  • Answers to the feedback questions are not linked to you or your account, so they cannot be found by person; they are deleted 12 months after they arrived. The same goes for a capture report you sent (Chrome 1.0.6 and later), which is deleted 90 days after it arrived. A report you emailed yourself is in the developer's mailbox: ask at the contact address below to have it deleted.

  • Delete .labr files and any other capture artifacts you retained from your Downloads folder. This does not delete synced captures or layers imported into Figma.

  • Copy something else and clear any operating-system or clipboard-manager history or sync record as appropriate.

  • If you used sync, turn it off to stop future uploads, then press Delete beside a listed capture in the paired plugin, or Delete flow for all captures in a listed flow. Confirm the action and check its result in the plugin. A failed request leaves the item available for retry. From Chrome 1.0.6, Remove beside a page in the panel's Recent tab deletes that page of the current flow on the service as well, after you confirm. Then use Clear Chrome connection in Chrome and Disconnect in the plugin. Each clears its local pairing settings and attempts server-side token revocation; if the server is unreachable, a token may remain valid. Disconnect does not delete captures already uploaded. Captures on the default Lillabr service expire after seven days and are deleted on a later sync request; another operator's retention may differ. For help with a deletion request that the plugin cannot complete, use the contact below. Do not send a device token or private capture in an email.

  • If you used the AI connector link (Chrome 1.0.6 and later), choose Delete now in Settings to remove every capture stored through it at once. Reset link does that too and makes the old link stop working; Turn off also deletes the link and makes Chrome stop staying connected for it. Forget allowed websites makes AI apps ask about each website again. Captures also expire on their own, an hour after an app last reads them and a day after they were made at most. Remove the connector from the AI app too, and delete what the app saved: its provider keeps what it received under its own terms. If Chrome cannot reach the service when you turn the link off, it tries again whenever it runs; until then, captures already stored can still be read through the link until they expire.

  • If you signed in with Google (Chrome 1.0.6 and later), Sign out in Settings (Account) forgets your email address, name and product-news choice in that browser. It does not delete your account at Lillabr's service, disconnect Cloud sync or delete captures. To delete your account, write to the contact address below from the address on the account; for now there is no button for it. Ask in the same email for your Cloud sync connections to be removed too, or use Clear Chrome connection and Disconnect as above, and delete what you saved in Cloud sync (captures expire after seven days anyway). To stop product news without deleting anything, use the unsubscribe link in a product-news email, or write to the same address. Removing Lillabr at chrome://extensions deletes the sign-in state and everything else it stored in the browser, not the account at Lillabr's service. Do not send a device token in an email.

  • Delete imported layers from your Figma file if you no longer want them there. Figma's own file and version history rules apply to that content.

  • Remove Lillabr at chrome://extensions, which deletes its settings and its extension-origin cache. Clearing the extension's site data does the same; this does not delete plugin settings, imported Figma layers, or synced captures.

Changes to this policy

If Lillabr ever starts sending anything anywhere else, this policy will be updated before that version ships, and the date at the top will change. It will also name any email service before the first email is sent through it.

Contact

Questions about this policy or a data request can be sent to www.geetanshsaini@gmail.com. The Terms of Use that you agree to with this policy on the first capture step are at lillabr.com/terms.