PROVIDER - Open-source form library you embed
SurveyJS
SurveyJS is an Estonian open-source survey and form library that describes forms in JSON Schema, lets you pick rendering, visual editor and data backend separately, and keeps responses on your own server.
3.7pts
Detailed Notes
Pros 5 items
Cons 4 items
Service Overview
SurveyJS is an Estonian survey and form library whose purpose is not to be another hosted survey tool but a component you embed in your own product. Within the Forms and Surveys category it sits on the developer side of the line: forms are described as JSON Schema, the frontend renders them, and your backend stores the answers, with the vendor supplying libraries and an editor.
The portfolio splits into four parts: the form rendering library that turns JSON into a fillable form, Survey Creator for visual editing by product or ops staff, a PDF generator that exports questionnaires and responses, and a dashboard for aggregation and charts. The renderer is MIT licensed while the creator and dashboard are commercial, so you can buy only the part you actually use.
The decision that matters is the boundary of responsibility. With a hosted survey SaaS the vendor owns creation, publishing, permissions and reporting. With SurveyJS you own all four, and in exchange the interface is fully under your control, data never leaves your systems, and brand and interaction can match the product exactly.
Key Strengths
- One schema, many runtimes: A JSON definition renders across React, Vue, Angular and Svelte, so changing frameworks or adding a second front end does not mean rewriting questions.
- Logic expressed declaratively: visibleIf, enableIf, requiredIf and expression functions encode multi-level dependencies inside the schema instead of scattering validation through component code.
- Clear data ownership: Your endpoint receives submissions and your database or object storage holds schemas, responses and attachments, so an audit can trace the full data path.
- Adopt piece by piece: The renderer is open source and the creator, PDF and dashboard are licensed separately, letting an existing frontend stack integrate block by block.
- Embedded feel: Surveys render as components inside the page, so themes and interaction stay consistent with the product instead of feeling like a third-party iframe.
Product Ecosystem
Platform capabilities
The renderer covers single-page and paged layouts, a wide set of question types (text, radio, checkbox, dropdown, matrix, file upload, rating, signature, expression), dynamic panels and per-question validation. The creator offers drag-and-drop authoring, logic configuration, localisation and theming, and can be embedded in your own admin area for non-developers. The dashboard aggregates responses per question with switchable charts.
Version cadence is worth noting. The libraries track frontend framework releases closely, and major upgrades usually require schema and style adjustments, so pin versions in the project and treat schemas as assets that need regression coverage.
Integrations
The renderer is backend-agnostic: any endpoint returning JSON can serve a schema and any endpoint accepting JSON can collect responses. Common setups keep schemas in a CMS or config table while responses go to a business database, use the PDF generator for archival copies, and fan submissions out to downstream systems through webhooks or a queue.
Typical scenarios
Forms embedded in SaaS products such as onboarding, KYC and satisfaction checks, internal approval and registration forms, patient or student questionnaires wired to an existing permission model, and products that resell survey capability to their own customers are the usual fits. For a one-off public survey that just needs to exist, it is a detour.
Limitations
- You build the whole stack: Creation, publishing, versioning, permissions, reporting and notifications all need implementation, and underestimating that work is the most common mistake in this kind of selection.
- Licensing is per seat: The creator and dashboard are charged per developer seat, so on larger teams the total can approach or exceed a mature SaaS, and budgets should scale with headcount rather than survey count.
- Schema maintenance is real work: Large forms reach hundreds of JSON lines, and without strong typing it is easy to write structurally valid but semantically wrong definitions, so version control and test cases are mandatory.
- Thin Chinese material: The interface can be localised, but Chinese documentation and support are limited, and edge cases are mostly resolved through GitHub issues and English docs.
Use Cases
- Forms embedded in SaaS products (★★★★★): Onboarding, KYC and satisfaction forms bound to your own account system are the natural fit for component rendering
- Industries with strict data sovereignty (★★★★☆): Finance, healthcare and public sector rules require data to stay in-house, making a self-owned backend a hard prerequisite
- Reselling survey capability (★★★★): White-label embedding inside customer systems with a fully consistent brand
- Internal approvals and registration forms (★★★★): Integrated with enterprise permissions and workflows, with schemas managed under version control
- Zero-ops standalone surveys (★★): Creation, publishing and reporting are all yours to build, so a finished SaaS wins for this case
Pricing
| Item | Price | Notes |
|---|---|---|
| Form rendering library | $0 | MIT licensed for commercial use, with full rendering and logic |
| Visual creator | Per developer seat subscription | Commercial licence, white-label and embedding options vary by tier, unit price follows the official quote |
| PDF export and analytics | Per developer seat subscription | Can be licensed separately or bundled with the creator |
| Enterprise licence | Sales quote | Source access, custom terms and dedicated support, usually annual |
Subscriptions are priced per developer seat and are independent of form count or response volume, with unit prices and tiers on the official pricing page. Budget by the number of engineers who will touch the library rather than by monthly users, since a single frontend owner makes the cost model very favourable.
FAQ
Is SurveyJS open source?
The core rendering library is MIT licensed and free for commercial use, while the visual creator, PDF generator and dashboard are commercial products requiring a subscription. Open source and entirely free are therefore two different questions, so confirm which parts you need before procurement.
Where is the data stored?
On your own backend. The library provides no hosted storage: submissions arrive at an endpoint you implement, and schemas plus responses live in your database or object storage. That is exactly why regulated industries adopt it.
Is it suitable for non-technical teams?
Not fully. Survey Creator lets operations staff build questions visually, but schema storage, publishing and the response endpoint still need engineering. At least one frontend or full-stack engineer has to own the integration.
How does it differ from Typeform or Jotform?
Typeform and Jotform are finished products that handle creation, publishing and reporting end to end. SurveyJS supplies components and an editor and leaves the rest to you. Choose it when survey capability must live inside the product and connect to your own accounts and data model; choose a finished product when a survey simply has to go out today.
Code Examples
Describe a form and its logic in JSON
{
"pages": [
{
"name": "plan",
"elements": [
{
"type": "radiogroup",
"name": "tier",
"title": "Choose a plan",
"isRequired": true,
"choices": [
{ "value": "basic", "text": "Basic" },
{ "value": "pro", "text": "Pro" }
]
},
{
"type": "text",
"name": "seats",
"title": "Seats",
"inputType": "number",
"visibleIf": "{tier} notempty"
},
{
"type": "expression",
"name": "quote",
"expression": "{tier} = 'pro' ? {seats} * 20 : {seats} * 10",
"visible": false
}
]
}
],
"showProgressBar": "top"
}
Expressions reference field names in braces, and the expression question type never renders: it exists purely to compute derived values such as a quote.
Render in React and submit to your own endpoint
// Schema and submit URL both come from your own service, tokens are injected from the environment
import { Model } from "survey-core";
import { Survey } from "survey-react-ui";
import "survey-core/defaultV2.css";
const schema = await fetch(process.env.SURVEY_SCHEMA_URL).then((r) => r.json());
const survey = new Model(schema);
survey.onComplete.add(async (sender) => {
const res = await fetch(process.env.SURVEY_SUBMIT_URL, {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: `Bearer ${process.env.SURVEY_API_TOKEN}`,
},
body: JSON.stringify({ answers: sender.data }),
});
if (!res.ok) {
// Surface the failure so the respondent can retry, otherwise the response is lost
throw new Error(`submit failed: ${res.status}`);
}
});
Always handle errors inside onComplete and prompt a retry; swallowing the exception silently drops the response.
Community & Resources
Official channels
- SurveyJS website — Product lineup, live examples and docs entry points
- SurveyJS documentation — Schema properties, expression syntax and component usage
- GitHub organisation — Framework packages and sample projects
- Pricing page — Tiers and billing for the commercial modules
Learning resources and tools
- JSON Schema specification — General reference for validating schema structure
- React documentation — Component lifecycle and state management basics
- MDN Fetch API — Error handling and timeouts when submitting responses