Guides

Install Featurevote on your website or app

Put your Featurevote board in front of users with a link, a one-line feedback bubble, your own button, or the board inside your page.

There are four ways to put Featurevote in front of your users, and one of them needs no code at all. Install and share in the sidebar gives you your board link at the top, then names the other shapes the same way this guide does and hands you the snippet for whichever you pick:

ShapeWhat your visitors see
Feedback bubbleA bubble in the corner of every page. One line, nothing to place.
Share a linkNothing installed — your board at its own address.
Your own buttonA button you place, opening a panel over the page.
Board in the pageThe board rendered inline, like any other section.

Start with the link if you just want a first vote today. Everything else is one script tag away.

The Install and share page, with the board link and a Copy link button at the top, and below it four shapes to pick from: Feedback bubble, Your own button with the feedback form, Your own button with the full board, and Board in the page
Install and share: your link first, then the four shapes, each with its snippet.

Feedback bubble: the one-line install

Paste this anywhere in your site's HTML. Before the closing </body> tag is the usual spot, and a site-wide layout means every page gets it:

<script src="https://your-account.featurevote.app/embed.v2.js" data-account="your-account" async></script>

Replace your-account in both places with your own — it is the first part of your board address, and the two must match. Loading the script from your board's own address rather than ours is what keeps the next section to a single origin.

A round feedback button appears in the bottom-right corner. It opens a card above itself, straight on the idea box, with a tab bar along the bottom (Feedback, Ideas, Roadmap and Updates), so visitors never leave the page. The Roadmap and Updates tabs follow the Show roadmap and Show changelog settings. Until an idea is on the roadmap or an update is published, they lead to Ideas. There is nothing to place and nothing to style.

You choose how it looks and what it opens on Install and share, with a working preview:

  • Opens on: the Feedback form (the default), your Board, your Updates, or a Private message box, which is just a message box.
  • Button appearance: Icon only, Icon and label for a button people can read at a glance, or Tab on the edge, which sits on the left or right side of the screen and opens a side panel.
  • Style: Solid is a dark button with a light rim, so it stands out on a white page, a dark app or a bright brand colour alike. Quiet is see-through glass that lets your page show through: light glass on a light page and dark glass on a dark or colorful one, so its symbol stays clear on a plain background. It picks the glass when the page loads, from the color behind it.
  • Symbol: a speech bubble, a light bulb or a heart. The same symbol shows in every shape. While the card is open it turns into an arrow, so the same spot closes it.
  • Button text: the words on the labelled button and the tab, and the name screen readers announce. Left empty, it says Feedback.
  • Where it sits: drag the button in the preview to where you want it. Let go on the left or right half and it sticks to that side, as far from the side and the bottom as you placed it (up to 160 pixels each), so it can clear a chat button or cookie notice. The tab slides up and down its edge instead. The Side choice and the distance fields set the same thing by keyboard.

Press Save changes and every site with your install code shows the new button within about a minute. The install code itself never changes, so there is nothing to paste again.

An attribute on the script tag still wins over the saved choice, for a page that needs its own:

<script src="https://your-account.featurevote.app/embed.v2.js" data-account="your-account" data-launcher="label" data-style="quiet" data-symbol="heart" data-position="left" data-offset="56" async></script>

data-launcher="label" shows the symbol and Feedback text, "tab" puts the tab on the edge and "icon" keeps the round button; data-label changes that text. data-style is "solid" or "quiet", and data-symbol is "bubble", "bulb" or "heart". data-offset sets the distance from the bottom and side in pixels, from 0 to 160 (default 24), and replaces both saved distances. The tab ignores it, since it hugs its side. Phone safe areas still apply. On a phone, the open panel follows the visible screen height so its controls stay reachable when the keyboard opens.

Optional attributes on the same tag: data-position="left" or "right" picks the corner, data-label sets the name screen readers announce, data-open="board" opens on the request list instead of the idea box, data-open="message" opens just a message box, data-panel-style="drawer" swaps the card for the edge drawer a placed button opens, and data-email / data-name pass the signed-in user (see Passing user identity). From your own CSS, --fv-offset (side and bottom), --fv-bottom (bottom only), --fv-tab-top (how far down its edge the tab sits, a number from 0 to 100) and --fv-z-index reposition it, and --fv-ink and --fv-on-ink recolor the solid button and its symbol.

The button sits at z-index: 40, below many common dialog layers. Your site's stacking contexts still decide what covers what. Adjust --fv-z-index or the spacing to fit your layout, and keep important controls such as Save buttons clear.

Show or hide the floating button

On Install and share, the visible Keep feedback out of the way → Hide the bubble during a task section has an example and Copy setup instructions for your developer or AI assistant, including your account’s install code and script-readiness handling.

Your app can hide the floating button while its own drawer, editor or checkout is open, and show it again afterward:

window.FeatureVote.hideLauncher(); // Your drawer opens
window.FeatureVote.showLauncher(); // Your drawer closes

These methods affect only the floating button. They do not close an open feedback panel, discard a draft, or hide buttons you placed yourself. The choice lasts for the current page, including single-page app navigation and widget re-initialization. A full page load returns to the script tag's setting.

To start hidden, add data-hide-launcher="true" to the script tag. Use this when feedback opens from your existing button or menu item. showLauncher() can still reveal the bubble later.

Call the methods after the embed script has loaded. With an async script, listen for featurevote:embed-ready before loading it, or check whether the API is already available:

function syncFeedbackLauncher() {
  // Replace editorIsOpen with your app's current drawer/editor state.
  if (editorIsOpen) window.FeatureVote.hideLauncher();
  else window.FeatureVote.showLauncher();
}

window.addEventListener('featurevote:embed-ready', syncFeedbackLauncher);
if (window.FeatureVote?.hideLauncher) syncFeedbackLauncher();
// Also call syncFeedbackLauncher whenever your editor opens or closes.

If your page already has a container of its own (the shapes below), the tag renders no floating button. The container wins.

On React, Next.js, Vue or any other framework that builds the page in JavaScript, the same one line goes in your root layout. See Frameworks (React, Vue, SPAs) for the example.

Just a message box

Inside your own app, where people are signed in and halfway through something, the full card can be more than they need. Add data-open="message" and the bubble opens one box instead, with no ideas, roadmap or updates around it:

<script src="https://your-account.featurevote.app/embed.v2.js" data-account="your-account" data-open="message" async></script>

What people write goes to your Feedback Inbox as a private message, with the page they were on, by its address and its title. So "we need a way to add breaks" arrives with the screen it is about. The address is sent without its query string or # part, where app URLs often keep session ids, and a line under the box tells people the page is included. When a message turns out to be an idea for everyone, Convert to Feature in the inbox puts it on your board.

It works the same on your own button with data-embed="panel". With data-embed="launcher" the button opens the box on its own page instead, which can't see the page people came from. This is always a private message box, with no public idea selector. The box is there whether or not Private messages is on in Settings → Access and submissions: that setting controls the private-message choice in the general feedback form, and this box is one you placed yourself.

The fastest way to collect your first vote. Copy your board link and drop it anywhere — an email, a Slack message, your onboarding flow, or a nav item.

https://your-account.featurevote.app

Point people at your product updates instead by adding ?tab=changelogs:

https://your-account.featurevote.app?tab=changelogs

With Known issues on, ?tab=issues opens your list of open bugs the same way.

Because it's just a link, you can build your own button or menu item and style it however you like — no widget required. To pre-fill the voter's identity, add query params (see Passing user identity below).

Your own button

Use an existing button or menu item

To keep your site's own button and styling, add data-featurevote-trigger. Load the script once with data-account and data-hide-launcher="true":

<button type="button" data-featurevote-trigger aria-haspopup="dialog">Feedback</button>
<script src="https://your-account.featurevote.app/embed.v2.js" data-account="your-account" data-hide-launcher="true" async></script>

The floating bubble stays hidden, and your button opens the same feedback experience. Without data-open it follows the Feedback bubble destination saved on Install and share. Add data-open="ask", "board", "changelogs" or "message" to the script to choose a destination for this installation. Keep feedback out of the way → Use your own button on Install and share gives you copyable code with your selected destination, your Hidden board key if needed, and optional identity placeholders.

You can put the attribute on multiple buttons or links, including ones added later by your framework. On a link, keep a real board href as a fallback while the script loads or if it is blocked. Standard modified clicks still follow that link. Before an async script loads, a plain button has no widget behavior, so disable it until ready if your framework needs loading feedback.

For an existing JavaScript or React click handler, call window.FeatureVote.open(event.currentTarget) after the script loads. Passing the button or link explicitly keeps repeated pointer clicks from dismissing and reopening the card, including on Safari where clicking a button does not necessarily focus it. It returns true if the feedback panel is open, or false if no floating launcher is initialized or an in-progress submission prevents switching panels. Calling it again while the same panel is open leaves the panel and draft intact. It works while the bubble is hidden, and does not make it visible. Without an argument, window.FeatureVote.open() opens feedback programmatically.

For an existing button with id="feedback-button":

document.getElementById('feedback-button').addEventListener('click', (event) => {
  window.FeatureVote.open(event.currentTarget);
});

Or in a React client component, after the embed script is ready:

<button type="button" onClick={(event) => window.FeatureVote.open(event.currentTarget)}>
  Feedback
</button>

Keep data-account on the script, not on your native button. An element with data-account is an embed container and featurevote fills it with its own content. The controls in this section use embed.v2.js; the legacy embed.js does not support them.

Use a featurevote button in your layout

A button you place yourself, opening a panel over the page. Paste it where you want the button to appear:

<div data-account="your-account" data-embed="panel"></div>
<script src="https://your-account.featurevote.app/embed.v2.js" async></script>

On Install and share, pick what it opens on. The Feedback form comes on its own, with no list and nothing to read first. Your Board lets a visitor on your pricing page or in your app read what others have asked for and upvote it in place, then carry on where they were, which is also how you stop collecting the same request five times. Updates and Private message are there too, and Button text changes its words. Press Save changes and every button with this code follows within about a minute, with nothing to paste again.

data-embed="panel" slides your board in over the page. A visitor halfway through writing something, or three levels into your app, can leave feedback and carry on — no page load, nothing lost. Use data-embed="launcher" instead if you'd rather send them to the board as a normal page.

A data-open on the <div> still wins over the saved choice, for a page that needs a button of its own, like a second button that always opens the board:

<div data-account="your-account" data-embed="panel" data-open="board"></div>

A code copied from Install and share before you could save these choices carries a data-open, so it keeps opening what it says. Paste the shorter code to have it follow what you save.

Voting is a single click. It needs no account and no email unless you set Visitor email to To vote, post and comment in Settings → Access and submissions. Posting a new request asks the visitor for an email, unless you set Visitor email to Not needed.

Keep data-embed="panel". Without it the snippet renders the full board inline in the page instead — that is Board in the page below.

Launcher options

Add these attributes to the <div> to change what the button does and how it reads:

AttributeValuesDefaultWhat it does
data-embedpanel, launcher—panel opens the board in a slide-in drawer; launcher navigates to it.
data-openboard, ask, message, changelogsyour saved choice²What the button opens: the board, a quick "suggest a feature" box, just a message box (with panel), or your product updates. Works on Board in the page too, where leaving it out opens the view you saved.
data-labelany textyour saved text, or per mode¹Overrides the button text.
data-target_self, _blank_selfOpen in the same tab or a new tab. Ignored by panel, which opens in place.
data-panel-styledrawer, carddrawerdrawer slides in from the edge and dims the page; card sits above the button with the page live around it.
data-panel-sideright, leftrightWhich edge the panel slides in from.
data-panel-widthany CSS size420pxPanel width on desktop. Phones always get a full-screen sheet.
data-email / data-namea value—Pre-fills the visitor's identity (see Passing user identity).
data-access-keyyour access key—Required only if your board is set to Hidden (see Hidden boards).

¹ The default label depends on the mode: Request feature (board), Give feedback (ask), Send feedback (message), View updates (changelogs).

² Left out on panel, the button opens what you saved on Install and share, the feedback form unless you pick another. On launcher it opens your updates.

How the panel behaves

  • data-open="ask" opens on the idea box, with the tab bar along the bottom. When both channels are available, Public idea and Private message are visible before anyone starts typing. Ideas appear on your board for others to vote on. Private messages go to your Feedback Inbox, where only the team sees them. If you've turned Private messages off in Settings → Access and submissions, the idea box is all there is. When private messages are available and public posting is closed, the private form is shown on its own.

  • One task at a time. The Feedback tab opens on the composer. Popular requests and updates stay in their own tabs; a live survey can appear on Ideas or after a successful submission.

  • Drafts stay while visitors move around. Text is kept separately for each visitor, board and channel in the current browser tab for up to 30 minutes. Switching tabs, changing channels or reopening the panel restores it. A successful submission clears that channel's draft; Discard draft clears it without sending. Attachments and contact details are not kept in the draft. If the browser blocks the storage or cryptography needed to separate visitors, feedback still works without saved drafts. While feedback is sending, the widget keeps the form open. Reloading or leaving the host page can still interrupt confirmation; if a draft returns afterward, check whether the message arrived before sending it again.

  • data-open="board" / "changelogs" show the board itself in the drawer, so people can read and vote on what's already there.

  • Closing it: the ✕ in its header, a click on the dimmed page behind it, or the Escape key. The bubble's card doesn't dim the page, so there it's the ✕ or Escape. After submission the panel shows a receipt: View your idea for a published idea, or Done for a private message or a request awaiting approval. The header's ✕ is also available once sending finishes. (In data-open="board" mode, Escape works while focus is on your page; once the visitor clicks into the board itself, use the ✕ or the dimmed area.)

  • It can't be covered or clipped. The panel renders in the browser's top layer, so your z-index values, overflow: hidden wrappers and transformed ancestors don't affect it — the button is safe to put anywhere, including inside your own modal.

  • If your site sends a Content-Security-Policy, the script and the board it opens come from the same origin, so the two directives that name us take the same value:

    script-src https://your-account.featurevote.app;
    frame-src  https://your-account.featurevote.app;
    

    script-src is what lets the snippet load at all — without it nothing happens and there is no error of ours in the console, because our code never runs. frame-src is what lets the board open inside the panel. Without it the panel shows a link that opens the board in a new tab instead, and the browser console names the exact frame-src value to add. (The same applies to the inline board embed.)

    Those two are the whole list. The embed makes no background requests, so it needs no connect-src, and it styles itself with a constructed stylesheet rather than an injected <style>, so a strict style-src leaves it alone. The one exception is a browser without constructable stylesheets (Safari below 16.4), where it falls back to a <style> element — if you support those and your style-src has no 'unsafe-inline', the button renders unstyled there.

You don't have to hand-write any of this. On the Install and share page, pick one of the two Your own button shapes, then open Customize → Customize the launch button. It sets the button label and the visitor's name and email, and copies the finished snippet for you. The mode comes from the shape you picked.

Styling — it already matches your site

By default the launcher inherits your site's text color and font, so it blends in on light and dark pages with no styling needed.

The launcher renders inside an isolated shadow root. That means two things:

  • Your page's CSS can't accidentally reach in and break the button — and the button's CSS can't leak out and affect your page.
  • Because of that isolation, you can't style it with ordinary selectors. Instead, the launcher exposes a deliberate, stable hook you're meant to target from your page's stylesheet.

This section is about a launcher you place yourself. The one-tag floating button is a different object, so --fv-bg and --fv-text do nothing there. It still answers to ::part(button), and adds ::part(glass) for its surface, ::part(ring) for its rim, and --fv-ink / --fv-on-ink for the solid style's colors. Note that [data-account] matches the floating host too, so scope brand CSS with [data-account]:not([data-featurevote-floating]) if you use both.

Two ways to theme it — pick based on how far you want to go:

1. Colors only — the --fv-* custom properties. The quickest option. Set these on the container and they flow through the shadow boundary into the button. Good when you just want brand colors:

[data-account] {
  --fv-bg: #4f46e5;   /* button background */
  --fv-text: #ffffff; /* button text + icon */
}

2. Full control — the ::part() selector. The launcher tags its button as part="button", which you can style like any element — including states like :hover. Use this when you want to change shape, padding, radius, or anything beyond color:

[data-account]::part(button) {
  background: #4f46e5;
  color: #ffffff;
  border-radius: 9999px;
  padding: 10px 18px;
  width: auto; /* the default is a full-width row; opt into a compact button */
}
[data-account]::part(button):hover { background: #4338ca; }

Theming the panel. The slide-in panel is a separate element that mounts itself on <body>, so it has its own hooks:

[data-featurevote-panel] {
  --fv-panel-width: 520px;                  /* desktop width */
  --fv-panel-bg: #ffffff;                   /* panel background */
  --fv-panel-text: #0f172a;                 /* header text */
  --fv-panel-backdrop: rgba(0, 0, 0, 0.6);  /* the dimmed page behind it */
}

/* …and ::part() for anything beyond color, as with the button: */
[data-featurevote-panel]::part(panel) { box-shadow: none; }
[data-featurevote-panel]::part(panel-close) { border-radius: 9999px; }

You can combine both — set the --fv-* colors and reach for ::part() only where you need more.

A note on shape: the default is a full-width row, designed to sit in a sidebar or nav column. For a compact inline button, set width: auto on ::part(button) as shown above.

Board in the page

Render your entire board inline, with no button and no panel — great for a help center, product portal, or internal dashboard. This is what a /feedback or /roadmap page on your own site is made of.

<div data-account="your-account"></div>
<script src="https://your-account.featurevote.app/embed.v2.js" async></script>

On Install and share you can pick which view it opens on: your Board, your Updates or the Feedback form. Press Save changes and every board with this code follows within about a minute. A data-open on the <div> wins over the saved view.

Optional sizing:

<div
  data-account="your-account"
  data-width="100%"
  data-height="600px"
  data-border="1px solid #e5e7eb"
></div>
<script src="https://your-account.featurevote.app/embed.v2.js" async></script>

Any CSS size works (600px, 80vh, 100%), and embed.v2.js treats a bare number like 760 as pixels. (On the legacy embed.js, always include a unit.)

The full-board embed also honors data-open (on embed.v2.js). Set data-open="changelogs" to open the embedded board directly on your product updates — handy when the embed lives on a "What's new" page:

<div data-account="your-account" data-open="changelogs"></div>
<script src="https://your-account.featurevote.app/embed.v2.js" async></script>

Unlike the launcher, there is no default here: leave the attribute out and the embed opens on the board's normal view, exactly as before.

Passing user identity

If your app knows who the visitor is, pass their name and email so the feedback form is pre-filled and their votes stay theirs on the next visit.

The two placeholders below are holes to fill from your own session, not values to paste. Left as they are, every visitor arrives as the same person and nothing reports it.

On a link, add query params:

https://your-account.featurevote.app?email={{SIGNED_IN_USER_EMAIL}}&name={{SIGNED_IN_USER_NAME}}

On a launcher or board embed, add data attributes:

<div
  data-account="your-account"
  data-email="{{SIGNED_IN_USER_EMAIL}}"
  data-name="{{SIGNED_IN_USER_NAME}}"
></div>
<script src="https://your-account.featurevote.app/embed.v2.js" async></script>

Hidden boards

If your product is behind a login, you may not want your board on the open internet. Settings → Access and submissions has four levels; these are the three that keep the embed working. Hidden comes with the Growth, Pro and Lifetime plans:

PublicUnlistedHidden
Your users, through the embedyesyesyes
A stranger who has the linkyesyesno
Google and other crawlersyesnono

Public is the default. On Hidden, copy the access key from the same screen and add it to your embed:

<div
  data-account="your-account"
  data-email="{{SIGNED_IN_USER_EMAIL}}"
  data-name="{{SIGNED_IN_USER_NAME}}"
  data-access-key="k_7Qm2xR9vTb4Lp"
></div>
<script src="https://your-account.featurevote.app/embed.v2.js" async></script>

That is the whole integration. Nothing to generate per user, nothing that expires, no server code.

Checking it works

Open your board's own URL — https://your-account.featurevote.app — with no key on the end. You should get "This board is hidden". That is exactly what a stranger with the link sees.

The check is reliable from any browser, including the one you just tested your own site in: nothing is remembered between visits, so the board decides on the key in the URL alone every time.

Two things worth knowing before you rely on it:

  • It stops strangers, not insiders. Anyone who can load your page can read the key in its source, and your own users can pass the link on. Use Regenerate on the access key if one gets out — the old key stops working within a few seconds, and you re-paste the new one.
  • It hides the board page, not the data behind it. Someone who knows how the API works can still read a hidden board's contents. That is why it is called Hidden and not Private.

Frameworks (React, Vue, SPAs)

There are two ways in, and the one-line install is the simpler of them.

The one line, from a root layout

Render the script tag itself, with its data-account attribute, and you get the floating feedback bubble with nothing to place. In Next.js that means next/script:

// app/layout.tsx
import Script from 'next/script';

export default function RootLayout({ children }) {
  return (
    <html>
      <body>
        {children}
        <Script
          src="https://your-account.featurevote.app/embed.v2.js"
          data-account="your-account"
          strategy="afterInteractive"
        />
      </body>
    </html>
  );
}

Two things make this work, and both are worth knowing before you trust it:

  • next/script passes data-account straight through to the rendered <script> element. Data attributes are not stripped.
  • document.currentScript is null for a tag React renders, so the embed does not rely on it. It scans the page for a script tag carrying data-account instead, and reads the account off that.

Keep strategy="afterInteractive". The floating bubble mounts on <body>, so a tag that runs before the body exists has nothing to attach to. This is the same installation we run on featurevote.app itself.

The optional attributes from Feedback bubble go on the same <Script>. Left off, the bubble keeps its own defaults, which are the Feedback name for screen readers and the idea box.

Any framework that can render a <script> tag with attributes works the same way. If yours cannot, put the one line in the HTML template your build starts from.

Apps with a signed-in area

A root layout is the right place on a marketing site, where every page is public. In a product it usually is not. The same root layout wraps your sign-in screen, your billing settings and every page rendering a customer's data, so a tag placed there loads third-party JavaScript into documents that hold passwords and account details.

Mount it on your authenticated subtree instead — the layout that already sits behind your auth check — and keep it off the auth routes themselves. In Next.js that means the layout inside your app group rather than the root one:

// app/(app)/layout.tsx — behind the auth check, not app/layout.tsx
<Script
  src="https://your-account.featurevote.app/embed.v2.js"
  data-account="your-account"
  strategy="afterInteractive"
/>

You give up nothing by doing it this way. A signed-out visitor on your login screen has nothing to give feedback about, and your signed-in pages are where the feedback actually comes from — it is also where data-email and data-name have a user to pass. If you want the bubble on your marketing pages too, add the tag to that layout separately rather than hoisting it back to the root.

Placing the container yourself

Load the script the same way, then initialize your own container after it mounts:

import { useEffect, useRef } from 'react';

function FeatureLauncher() {
  const ref = useRef(null);

  useEffect(() => {
    const init = () => window.FeatureVote?.initEmbeds(ref.current);
    init();
    window.addEventListener('featurevote:embed-ready', init, { once: true });
    return () => window.removeEventListener('featurevote:embed-ready', init);
  }, []);

  return (
    <div ref={ref} data-account="your-account" data-embed="launcher" data-open="board" />
  );
}

The same pattern applies to Vue (template ref + onMounted) and other frameworks — call window.FeatureVote.initEmbeds(el) once the container is in the DOM.

If the attributes change after that first render, which is the normal case when your session loads asynchronously and data-email only arrives a moment later, set them and then rebuild:

el.dataset.email = user?.email ?? ''; // empty when signed out
el.dataset.name = user?.name ?? '';

window.FeatureVote?.reset?.(el);
window.FeatureVote?.initEmbeds?.(el);

The reset is the part that matters. On its own, initEmbeds skips a container it has already rendered into, so the new values are read only once the previous render is torn down — and nothing reports the difference. The launcher preview on the Install and share page uses this same sequence.

A container of your own always wins. When one mounts, the floating button steps aside, so you never end up with two ways in on the same page.

Platforms (WordPress, Shopify, Webflow…)

Any platform that allows custom HTML works. Look for a "Custom HTML" or "Embed Code" block and paste the snippet. On WordPress you can pass the logged-in user's identity:

<div
  data-account="your-account"
  data-email="<?php echo esc_attr( wp_get_current_user()->user_email ); ?>"
  data-name="<?php echo esc_attr( wp_get_current_user()->display_name ); ?>"
></div>
<script src="https://your-account.featurevote.app/embed.v2.js" async></script>

Not sure which to use?

Start with the link — it is the fastest path to your first real vote, and it needs nothing from your codebase.

Then add the feedback bubble if you want an entry point on every page and would rather not think about where to put it. Place your own button instead when you have a natural home for it already, like a nav bar, help menu or footer, or when you want it on some pages and not others. Reach for board in the page when the board is the page.

They are not exclusive. A bubble on every page and a full board on your /roadmap is a normal combination — the container always wins where it appears, so the two do not fight.