https://feedvalue.com/blog 2026-05-16T00:04:02.976Z https://github.com/jpmonette/feed FeedValue Team https://feedvalue.com Developer guides, product comparisons, and best practices for collecting user feedback. Copyright 2026 FeedValue https://feedvalue.com/blog/feedvalue-vs-canny 2026-02-12T00:00:00.000Z

``` That's the entire integration. Paste it before your closing `` tag, deploy, and your users can submit feedback. The widget JavaScript loads asynchronously from [Cloudflare's CDN](https://www.cloudflare.com/application-services/products/cdn/) at roughly 5-10KB. Your page speed won't notice. Before copying the script tag, you can customize the widget's appearance, position, colors, and behavior through the [visual widget builder](https://feedvalue.com/features). Or skip it and use the defaults. Either way, you're live in under a minute. Setting up Canny involves creating an account, configuring a feedback board, customizing the board's theme, optionally setting up a custom domain, inviting team members, and wiring up integrations. It's not difficult, but it takes more than 60 seconds. Canny is a platform you configure. FeedValue is a widget you embed. For developers who want to ship fast and iterate later, that difference is significant. You can have feedback collection running on your production site this afternoon. Deciding between board layouts can wait. ## Both tools connect to your workflow Canny and FeedValue overlap in one key area: workflow integrations. Canny and FeedValue both connect to [**Slack**](https://slack.com/) for real-time notifications when new feedback arrives. They also integrate with **Jira** and **Linear** so you can turn feedback into trackable issues without copy-pasting between tools. On Canny, Jira and Linear integrations require the Pro plan ($79/mo base price, plus tracked-user scaling on top). On FeedValue, these same [integrations](https://feedvalue.com/integrations) are on the Pro plan at $49/mo flat. FeedValue also includes role-based access control with three roles: Owner, Admin, and Member. Invite your whole team, control who can change settings versus who can view and respond to feedback, and keep everyone aligned on what users are saying. ## Is FeedValue the right Canny alternative? Three questions cut through the comparison: 1. **Do you need public feature voting?** If yes, use Canny or Featurebase. FeedValue doesn't do voting boards. 2. **Do you want feedback embedded in your product?** If yes, use FeedValue. Canny requires users to visit a separate page. 3. **Is cost predictability important as you grow?** If yes, FeedValue's flat pricing removes the guesswork. Canny's tracked-user model means your bill compounds with engagement. If you answered "no, yes, yes," FeedValue is your Canny alternative. If you answered "yes, no, either," Canny or a similar voting board tool is the better fit. No hard feelings. If you answered "yes, yes, yes," you can use both. Run a public voting board for roadmap prioritization and an embedded widget for in-context bug reports and quick feedback. They solve different problems and complement each other. Read our [feedback widget comparison guide](https://feedvalue.com/blog/website-feedback-widgets) for more on how embedded widgets fit into a broader feedback strategy. And if you're also evaluating survey tools, see [why Typeform isn't built for product feedback](https://feedvalue.com/blog/typeform-alternative-feedback). ## Try FeedValue free Add a feedback widget to your site in 60 seconds. FeedValue's free trial requires no credit card. [Start your free trial](https://feedvalue.com/signup), copy the script tag, and collect your first response today. Plans start at [$19/mo](https://feedvalue.com/pricing). Check the [setup guide](https://docs.feedvalue.com) if you want the full integration walkthrough. ]]> FeedValue Team https://feedvalue.com/blog/reaction-widgets-vs-feedback-forms 2026-02-10T00:00:00.000Z

``` That single script tag renders inline reaction buttons wherever you place them. The widget weighs 5-10KB and loads from [Cloudflare's CDN](https://www.cloudflare.com/application-services/products/cdn/), so it won't affect your page speed. See the [setup guide](https://docs.feedvalue.com) for customization options and framework-specific instructions. ### Where reaction widgets work well - **Documentation pages.** "Was this helpful?" with a thumbs up/down captures whether your docs solve the problem. Teams running HappyReact or similar tools on their docs consistently report that reaction data helps them prioritize which pages to rewrite first. - **Blog content.** Emoji reactions below articles give you a sentiment signal without asking readers to fill out a form. - **Feature releases.** After launching a new feature, a quick reaction widget on the feature page tells you whether the initial response is positive or confused. - **High-traffic pages.** When thousands of users pass through a page daily, even a 1% reaction rate produces meaningful data. ### What reaction widgets don't do Reaction widgets give you direction, not detail. A thumbs-down on your pricing page tells you something is wrong. It doesn't tell you whether the price is too high, the tiers are confusing, or a specific feature is missing. For that, you need a form. ## What is a feedback form? A **feedback form** is a structured input that collects detailed written responses. In the context of embedded widgets, this usually means a modal that opens on button click, with fields for a message, optional category selection, and sometimes an email address or screenshot attachment. Unlike standalone tools like Typeform or Google Forms that redirect users to a separate page, a feedback form widget keeps users in your app. The form opens as an overlay, the user submits, and they're back where they started. Here's the same one-line FeedValue embed, configured for a [feedback form widget](https://feedvalue.com/features/feedback-widget): ```html ``` Same script tag, different widget type. You choose between Feedback and Reaction widgets in the [visual widget builder](https://feedvalue.com/features/widget-builder) when you create the widget. ### Where feedback forms work well - **Feature requests.** "What feature would make this product more useful to you?" requires a text field, not a thumbs up. - **Bug reports.** Users need space to describe what went wrong, what they expected, and what they were doing when it happened. - **Onboarding feedback.** After a user completes setup, a short form asking "What almost stopped you from finishing?" gives you actionable detail. - **Churn prevention.** When a user cancels, an exit survey captures why. This data directly informs retention strategy. - **Post-purchase or post-interaction.** Specific moments where you need context, not just sentiment. ### What feedback forms don't do Feedback forms have friction. Even a short one takes 30 to 120 seconds to complete. On mobile, that friction increases. UX research consistently shows that users reflexively close popup forms if they appear at the wrong moment. One study on [popup UI patterns](https://www.eleken.co/blog-posts/popup-ui) found that contextual inline prompts doubled activation rates compared to popup approaches, because inline elements avoid the "learned dismissal" that years of aggressive popups have trained into users. The result: feedback forms collect fewer responses than reaction widgets, but each response carries more information. ## Head-to-head comparison Here's a practical comparison to help you decide which approach fits your situation. | Factor | Reaction widget | Feedback form | |--------|----------------|---------------| | User effort | One click | 30-120 seconds | | Response rate | High (up to ~25% interaction rate) | Lower (5-15% completion rate) | | Data type | Quantitative sentiment | Qualitative detail | | Best data for | Trends, volume, satisfaction scores | Root causes, feature ideas, bug details | | User disruption | None (inline) | Low to medium (modal overlay) | | Mobile experience | Excellent (tap-friendly) | Varies (depends on form length) | | Setup complexity | One script tag | One script tag (same embed) | | Analysis effort | Low (counts and percentages) | Higher (reading and categorizing text) | Neither approach is better in absolute terms. They solve different problems. If you're collecting feedback on **content quality**, reaction widgets give you signal at scale. If you're collecting feedback on **product direction**, forms give you the detail you need to act. For a broader comparison of widget types and tools, see our [website feedback widgets guide](https://feedvalue.com/blog/website-feedback-widgets). ## A decision framework If you've been debating feedback widget vs. survey, the answer depends on what you need to learn. Instead of choosing one or the other permanently, choose based on the question you're trying to answer. **Use a reaction widget when:** 1. You want to measure satisfaction or sentiment across a large number of users 2. The feedback context is clear (e.g., a specific help article, a feature page) 3. You need a high response rate and can trade depth for volume 4. You're collecting data to identify *which* areas need attention, not *how* to fix them 5. The audience is mobile-heavy and form friction would tank response rates **Use a feedback form when:** 1. You need to understand *why* users feel the way they do 2. You're collecting feature requests, bug reports, or improvement ideas 3. The user just completed a meaningful interaction (onboarding, purchase, cancellation) 4. You'll read and act on individual responses, not just aggregate scores 5. You have fewer users but need richer data from each one **Use both when:** 1. You have different page types that need different collection methods 2. You want volume data *and* qualitative depth from the same user base 3. You're at a stage where reaction data helps you prioritize which areas to dig into with forms That last point leads to the most effective approach. ## The hybrid approach: reactions first, forms second The strongest feedback systems combine both methods. Here's the pattern: 1. **Place reaction widgets on high-traffic pages.** Docs, blog posts, feature pages, dashboard screens. Collect sentiment at volume with zero friction. 2. **Place feedback forms at key decision points.** Post-onboarding, post-cancellation, settings pages, feature request buttons. Collect detail where context matters. 3. **Use reaction data to prioritize.** When your docs page for "API authentication" gets 40% thumbs-down reactions, that's your signal to dig deeper. Add a feedback form to *that specific page* asking "What's missing or confusing?" Now your form targets a known problem instead of fishing for general input. This hybrid approach is a form of progressive disclosure applied to feedback. Reactions handle the initial sentiment analysis at volume. Forms collect the qualitative detail you need to act. Volume data tells you *where* to look. Form data tells you *what to do*. ### How this works in FeedValue [FeedValue](https://feedvalue.com/features) supports both Reaction and Feedback widgets natively. You create each widget type in the [widget builder](https://feedvalue.com/features/widget-builder), customize its appearance to match your brand, and embed it with the same one-line script tag: ```html ``` Both widget types feed into the same [dashboard](https://feedvalue.com/features/dashboard). Your team sees reaction trends and form responses side by side. If you're on the Pro plan ($49/mo), new responses trigger [Slack notifications](https://feedvalue.com/integrations/slack) and can be turned into [Jira](https://feedvalue.com/integrations/jira) or [Linear](https://feedvalue.com/integrations/linear) issues directly from the dashboard. Most tools in this space only offer one type. Canny does feature voting boards. Hotjar bundles emoji reactions inside an analytics suite with heatmaps and session recordings you might not need. Typeform builds great standalone surveys but doesn't embed as a native widget. FeedValue gives you both widget types, both in your app, both in one dashboard. [See the pricing plans](https://feedvalue.com/pricing) to find the right fit for your team. ## Five mistakes to avoid **1. Using forms when reactions would suffice.** If you're asking "Was this page helpful?" via a three-field form, you're creating unnecessary friction. A thumbs up/down captures the same signal with one click instead of 30 seconds of typing. **2. Using only reactions when you need actionable detail.** A thumbs-down on your checkout page doesn't tell your team whether the issue is pricing, payment options, or a UI bug. When you need to *act* on feedback, you need words, not just clicks. **3. Triggering forms as random popups.** Users have been trained by years of aggressive popup surveys to close them reflexively. Trigger forms based on user actions (completed onboarding, clicked a feedback button, visited a specific page) rather than on page load or timers. Modals that respond to user action are fine. Modals that interrupt a task are not. **4. Collecting reactions without reviewing the data.** Reaction widgets are low-effort to set up and low-effort to ignore. If you're collecting thumbs-up data on 50 pages but nobody looks at the dashboard, you're wasting the embed. Set a weekly or biweekly cadence to review reaction trends and identify pages that need attention. **5. Overloading a single feedback form.** Every additional field reduces your completion rate. If you need a bug report, ask for a description and optionally an email. Don't add category dropdowns, priority selectors, and NPS ratings to the same form. Keep each form focused on one type of feedback. ## Getting started Here's a practical starting point if you're adding feedback collection to your site for the first time: 1. **Pick your highest-traffic pages** (homepage, docs, pricing) and add a reaction widget. This takes about 60 seconds per page with a script tag embed. 2. **Pick your highest-intent moments** (post-signup, post-cancellation, feature request button) and add a feedback form. Same embed process. 3. **Review reaction data weekly.** Look for pages with low satisfaction scores. Those are your candidates for deeper investigation with targeted forms. 4. **Review form responses as they arrive.** Set up [Slack notifications](https://feedvalue.com/integrations/slack) so your team sees feedback in real time, not during a monthly review. FeedValue's [free trial](https://feedvalue.com/signup) includes both widget types, the dashboard, and the widget builder. You can set up reactions and forms in under 10 minutes. No credit card required. [Start your free trial](https://feedvalue.com/signup) ## Frequently asked questions ### What is a reaction widget? A reaction widget is an inline feedback element that lets users express sentiment with a single click. Common formats include thumbs up/down buttons, emoji faces (happy, neutral, sad), and star ratings. Reaction widgets sit within the page content and don't open modals or navigate away. They're designed for quick, low-friction feedback collection. ### When should I use a feedback form instead of a reaction widget? Use a feedback form when you need qualitative detail. Feature requests, bug reports, and exit surveys all require users to describe their experience in words. If a single thumbs up or thumbs down wouldn't give your team enough information to take action, use a form. ### Can I use both reaction widgets and feedback forms on the same site? Yes. Most feedback strategies benefit from both. Use reaction widgets on high-traffic pages for volume data and feedback forms at key interaction points for depth. Tools like [FeedValue](https://feedvalue.com/features) support both widget types from a single dashboard with the same one-line embed. ### What response rates can I expect from reaction widgets? Reaction widgets typically see interaction rates around 25% on pages where they're visible and contextually relevant (like "Was this helpful?" on a docs page). Feedback forms see completion rates of 5-15%, depending on form length and timing. The gap exists because reactions require one click while forms require typing. ### Do reaction widgets slow down my website? It depends on the tool. Lightweight reaction widgets like FeedValue's (5-10KB, served from Cloudflare's CDN, loaded asynchronously) have negligible impact on page speed. Heavier tools that bundle analytics, heatmaps, or session recording alongside feedback collection can add meaningful load time. Check the bundle size before you embed. ]]> FeedValue Team https://feedvalue.com/blog/typeform-alternative-feedback 2026-02-11T00:00:00.000Z

``` That's the entire integration. Paste it before your closing `` tag, deploy, and your feedback channel is live. See the full [setup guide](https://docs.feedvalue.com) for framework-specific instructions. ### Two widget types for different contexts Sometimes you need detailed feedback. Sometimes you just need a pulse check. FeedValue handles both with two widget types: **Feedback widget:** A modal form that slides in when triggered. Users can type detailed feedback, feature requests, or bug reports. You configure the fields, colors, position, and trigger button through a [visual widget builder](https://feedvalue.com/features/widget-builder), no code required. **[Reaction widget](https://feedvalue.com/features/reaction-widget):** Inline buttons for quick sentiment capture. Thumbs up/down, emoji reactions, or star ratings. One click, zero typing. Useful for gauging response to a new feature, a help article, or a pricing change. (For a deeper comparison of when to use each type, see [reaction widgets vs. feedback forms](https://feedvalue.com/blog/reaction-widgets-vs-feedback-forms).) Typeform can do the first one (as an external form). It can't do the second one at all. ### Real-time notifications and workflow When a user submits feedback through the widget, three things happen: 1. The response appears in your FeedValue dashboard immediately 2. A notification lands in your connected Slack channel 3. Your team can create a Jira or Linear issue directly from the response The feedback goes from "user thought" to "ticket in your backlog" in under a minute, without anyone checking a spreadsheet or copying text between tabs. ## FeedValue vs. Typeform: a Typeform alternative built for feedback Here's a direct comparison for the specific use case of collecting product feedback from your users: | Feature | FeedValue (Pro, $49/mo) | Typeform (Plus, $50/mo) | |---------|------------------------|------------------------| | Responses included | 5,000/mo | 1,000/mo | | Embedded in your app | Yes, native widget | Iframe or redirect | | Reaction widgets | Yes (thumbs, emoji, stars) | No | | Real-time dashboard | Yes, with status tracking | Basic results view | | Slack integration | Native, included | Via Zapier ($20+/mo extra) | | Jira integration | Native, included | Via Zapier ($20+/mo extra) | | Linear integration | Native, included | Not available | | White-label | Yes, included on Pro | Requires Plus plan ($50/mo) | | Custom CSS | Yes, included on Pro | Limited styling options | | Widget file size | 5-10KB | Full iframe embed | | Setup time | One script tag (~60 seconds) | Form design + embed config | | Auto-upgrade on limit | No, we notify you | Yes, silent upgrade | At the same price point, FeedValue gives you five times the responses, native dev tool integrations, and an embedded widget instead of a redirect. For the specific job of product feedback collection, the tools aren't comparable. If you want to see for yourself, [start a free trial](https://feedvalue.com/signup). No credit card required. Your first feedback can arrive in under five minutes. ## When you should still use Typeform This isn't a "Typeform is bad" article. Typeform is excellent for things that are actually surveys: - **Market research** with complex branching logic and conditional paths - **Lead generation forms** where the conversational UX drives higher completion rates - **Event registrations** and signup forms with payment collection - **Quizzes and assessments** where the one-question-at-a-time format adds engagement - **Customer satisfaction surveys** sent as a campaign to a specific audience If you're asking a defined set of questions to a defined audience at a defined time, Typeform is built for that. If you're building a permanent channel for users to share unstructured thoughts, requests, and bug reports while they're using your product, that's a different job. That job needs a [feedback widget](https://feedvalue.com/blog/website-feedback-widgets), not a survey form. ## The bottom line Use Typeform for surveys. Use a feedback widget for feedback. The tools look similar on the surface. Both collect user input. Both have customizable forms. But the architecture is fundamentally different. Surveys are campaigns you push out. Feedback widgets are channels you leave open. Surveys redirect users. Widgets stay in context. Surveys give you a spreadsheet. Widgets give you a dashboard with workflow integration. If you've been using Typeform for product feedback and feeling the friction (response caps, redirect UX, no Jira integration, no real-time dashboard), the best Typeform alternative isn't another form builder. It's a different category of tool entirely. FeedValue is a feedback widget that embeds in your app with one script tag. Responses flow to a dashboard, your Slack, and your issue tracker. [Plans start at $19/mo](https://feedvalue.com/pricing) with 500 responses, and Pro at $49/mo includes Slack, Jira, Linear, white-label, and 5,000 responses. [Try FeedValue free for 7 days](https://feedvalue.com/signup). Paste one line of code. See your first feedback in five minutes. ]]> FeedValue Team https://feedvalue.com/blog/website-feedback-widgets 2026-02-09T00:00:00.000Z

`, done) 2. **npm package** (install, import, configure in your component tree) 3. **SDK with initialization** (multiple steps, API keys, configuration objects) 4. **iframe embed** (paste an iframe, limited customization) If you're looking for a simple feedback widget, the script tag approach gets you live in under five minutes. An npm package makes sense if you need framework-level control. Iframes are the worst option for customization and performance. ### Customization depth A customizable feedback widget gives you control over colors, position, and button text through a UI at minimum. Beyond that: - **Custom CSS** lets you match the widget to your design system pixel by pixel. - **White-label** removes the vendor's branding from the widget. Essential if you're an agency or building client-facing products. - **Trigger control** determines when the widget appears (page load, button click, scroll depth, exit intent). ### Integrations A widget that collects feedback but doesn't connect to your workflow creates another silo. The integrations that matter most for developer teams: - **Slack** for real-time notifications when feedback arrives - **Jira** or **Linear** for turning feedback into trackable issues - **Webhooks** for connecting to anything else ### Pricing model Feedback widget pricing varies wildly. Some charge per seat, some per response volume, some per "project" or "app." Compare the unit that matters to you. For most startups, response volume is the constraint. A tool that charges $99/month for unlimited responses is only worth it if you're actually collecting thousands. ## Best website feedback widgets in 2026 ### 1. FeedValue **Best for:** Developers and startups who want the fastest path from zero to collecting feedback. [FeedValue](https://feedvalue.com) is a feedback widget you add with one script tag. It supports two widget types: a Feedback widget (modal form for detailed responses) and a Reaction widget (inline buttons for quick sentiment). You customize both in a visual widget builder, and responses show up in a centralized dashboard. What makes it different from most tools on this list: it was built by developers for the developer workflow. The widget script is around 5-10KB, served from Cloudflare's CDN. Setup is one line of HTML. The Pro plan includes Slack, Jira, and Linear integration, so feedback flows directly into your existing tools. Here's the embed: ```html ``` **Pricing:** Starter at $19/month (2 apps, 500 responses). Pro at $49/month (5 apps, 5,000 responses, integrations, white-label). Business at $99/month (15 apps, 50,000 responses, unlimited team members). **Strengths:** Lightest bundle size on this list. Fastest setup. Affordable entry price. Clean developer experience with API key management and rotation. **Limitations:** Newer product. Analytics dashboard is on the roadmap, not shipped yet. No public voting board (that's Canny's territory). ### 2. Hotjar **Best for:** Teams who want behavior analytics and feedback in one tool. Hotjar combines heatmaps, session recordings, and feedback surveys in a single product. The feedback widget is one feature inside a broader analytics suite. If you already use Hotjar for heatmaps and want to add a quick feedback button, it's convenient. But when you only need feedback, you're loading a heavier script for features you won't use. **Pricing:** Free tier available. Plus at $39/month. Business at $99/month. **Strengths:** Strong brand. Heatmaps and recordings are valuable for UX teams. Free tier for getting started. **Limitations:** Feedback is a secondary feature, not the core product. Heavier script than dedicated feedback widgets. Limited integrations for feedback-specific workflows (no native Jira or Linear). ### 3. Usersnap **Best for:** QA teams who need visual bug reporting with technical metadata. Usersnap captures annotated screenshots, browser info, and console logs alongside feedback. It's built for bug reporting during development and testing. Users can draw on their screen to highlight issues and the tool captures technical context automatically. **Pricing:** Starter at $39/month (2 projects). Company at $99/month (10 projects). **Strengths:** Detailed visual feedback with annotations. Technical metadata capture (browser, console, network). Good for QA workflows. **Limitations:** Overkill for simple product feedback or feature requests. More complex than needed if you just want users to tell you what they think. Pricier entry point than simpler alternatives. ### 4. Canny **Best for:** Product teams who want public feature voting and roadmap visibility. Canny provides a voting board where users submit and upvote feature requests. It includes roadmap visualization and a changelog. The catch: it's not an embeddable widget. Users leave your product to visit your Canny board. **Pricing:** Growth at $99/month. Business at $399/month. **Strengths:** Established brand in the feedback space. Public voting boards create user engagement. Strong roadmap features. **Limitations:** Not a widget; it's a separate page. Users leave your app to give feedback. Expensive entry point. Complex for teams that just need simple feedback collection. ### 5. Featurebase **Best for:** Teams who want a free tier with feedback collection and a public roadmap. Featurebase is a newer entrant that combines embedded feedback widgets with voting boards, roadmaps, and changelogs. The free tier is generous, the UI is clean, and setup is fast. Worth watching as a rising competitor. **Pricing:** Free tier available. Paid plans start around $49/month. **Strengths:** Modern UI. Free tier for getting started. Combines feedback collection with roadmap features. Good documentation. **Limitations:** Some features gated behind higher tiers. Newer product, smaller community. ### 6. Typeform **Best for:** Teams who need polished, multi-step surveys (not in-app feedback). Typeform creates beautiful conversational forms with a one-question-at-a-time UX. It's great for customer research surveys, lead generation, and detailed questionnaires. For embedded in-app feedback, it's not the right tool; responses go through an iframe or redirect. **Pricing:** Basic at $25/month. Plus at $50/month. **Strengths:** Beautiful form design. High completion rates for surveys. Versatile (forms, quizzes, lead gen). **Limitations:** Not truly embeddable as an in-app widget. Users see an iframe or leave the page. No real-time feedback dashboard. No native Jira or Linear integration. Per-response pricing can get expensive. ### 7. Survicate **Best for:** Teams focused on NPS, CES, and structured surveys within their product. Survicate specializes in targeted surveys: NPS scores, customer effort scores, and satisfaction surveys. The widget triggers surveys based on user behavior, which is useful for measuring specific touchpoints. **Pricing:** Starts around $59/month. **Strengths:** Good targeting and segmentation. Strong survey methodology. Multi-channel (web, email, mobile). **Limitations:** Oriented toward structured surveys, not open-ended feedback. More expensive than simpler options. Better for research teams than developer teams. ### 8. Appzi **Best for:** Solo projects that need a free feedback button with minimal setup. Appzi offers a simple feedback widget with a free plan that supports unlimited surveys. It's straightforward: pick an icon or text for the button, customize colors, and embed. Less feature-rich than other options, but the free tier is genuine. **Pricing:** Free plan available. Basic at $29/month. **Strengths:** Free tier with unlimited surveys. Simple setup. Multiple survey languages. **Limitations:** Limited integrations. Less customization depth. Smaller company with a narrower feature set. ## How to add a feedback widget to your website Whether you want to embed a feedback widget using plain HTML, JavaScript, or a framework like React, most tools follow the same pattern: paste a script tag into your HTML. Here's what that looks like in practice. ### HTML (any website) Add this before the closing `` tag: ```html ``` Replace `YOUR_WIDGET_ID` with the ID from your widget builder. Deploy your site. The widget appears automatically. The `async` attribute means the script loads without blocking your page render. Your Core Web Vitals stay healthy. ### React If you're using React, install the `@feedvalue/react` package instead of the script tag. This JavaScript feedback widget gives you a provider and a hook: ```bash npm install @feedvalue/react ``` Wrap your app in `FeedValueProvider`: ```tsx import { FeedValueProvider, useFeedValue } from '@feedvalue/react'; function App() { return ( ); } function FeedbackButton() { const { open, isReady } = useFeedValue(); return ( Give Feedback ); } ``` The `useFeedValue` hook gives you `open`, `close`, `submit`, `identify`, and more. You can also run in headless mode to build a completely custom feedback UI while FeedValue handles the backend. For **Next.js**, use the same provider in your root layout. With the App Router, add it to `app/layout.tsx`. With Pages Router, wrap it in `pages/_app.tsx`. ### Vue Install the `@feedvalue/vue` package: ```bash npm install @feedvalue/vue ``` Register the plugin in your app entry: ```typescript import { createApp } from 'vue'; import { createFeedValue } from '@feedvalue/vue'; import App from './App.vue'; const app = createApp(App); app.use(createFeedValue({ widgetId: 'YOUR_WIDGET_ID', })); app.mount('#app'); ``` Then use the `useFeedValue` composable in any component: ```vue ``` For **Nuxt 3**, register the plugin in `plugins/feedvalue.client.ts`. ### WordPress For WordPress, paste the script tag into your theme's footer via **Appearance > Theme Editor > footer.php**, or use a plugin like Insert Headers and Footers. If you're using a page builder, most have an HTML block where you can paste the script directly. ## Feedback widget vs. feedback form vs. survey tool These three terms get used interchangeably, but they solve different problems. | | Feedback widget | Feedback form | Survey tool | |---|---|---|---| | **Where it lives** | Embedded in your app/site | Standalone page or iframe | Separate URL or iframe | | **User experience** | User stays in context | User leaves current flow | User leaves current flow | | **Best for** | In-app feedback, quick reactions | Contact forms, support requests | Research, NPS, customer surveys | | **Response depth** | Short to medium | Medium | Long, structured | | **Setup** | Script tag or npm package | HTML form or form builder | Form builder with logic | | **Example tools** | FeedValue, Usersnap, Appzi | Google Forms, Formspree | Typeform, SurveyMonkey, Survicate | If you want users to give feedback inside your product, without leaving the page, a widget is the right choice. If you need a standalone survey with branching logic and 20 questions, use a survey tool. Don't force a survey tool into a widget-shaped hole. ## Pricing comparison Here's a side-by-side of the eight tools covered in this guide, sorted by entry price. | Tool | Entry Price | Responses | Apps/Projects | Integrations | Widget Type | |------|------------|-----------|---------------|--------------|-------------| | Appzi | Free | Unlimited | Limited | Basic | Feedback button | | Featurebase | Free | Varies | Varies | Moderate | Widget + voting board | | FeedValue | $19/month | 500/month | 2 | Slack, Jira, Linear (Pro) | Feedback + Reaction | | Typeform | $25/month | Limited | N/A | Zapier | Survey forms | | Hotjar | $39/month | Varies | N/A | Basic | Feedback + analytics | | Usersnap | $39/month | Varies | 2 | Jira, Slack | Visual feedback | | Survicate | ~$59/month | Varies | N/A | Multiple | Survey widget | | Canny | $99/month | Unlimited | Varies | Jira, Slack | Voting board (not widget) | Two patterns stand out. First, the cheapest tools with genuine free tiers (Appzi, Featurebase) trade depth of integrations for price. Second, the expensive tools (Canny, Survicate) serve different use cases entirely; you're paying for voting boards or structured survey methodology, not a simple feedback widget. For a developer or startup team that needs a feedback widget for their website with real integrations, the sweet spot is $19-49/month. That gets you a widget, a dashboard, and connections to the tools your team already uses. ## Start collecting feedback on your site today Pick a widget. Paste the script tag. Deploy. If you want the fastest setup with the lightest footprint, try FeedValue free for seven days. One script tag, two widget types, and a dashboard with Slack and Jira integration on the Pro plan. No credit card required. ]]> FeedValue Team