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.

Form & Survey Estonia 2026.11.20
3.7pts

Detailed Notes

Pros 5 items

Forms are described by a JSON schema, so one definition renders across 6+ frameworks including React, Vue, Angular and Svelte
The core form library is MIT licensed, while the visual creator, PDF export and analytics dashboard are 3 commercial modules licensed on demand
Conditional logic runs on expressions, combining visibleIf, enableIf, requiredIf and custom functions so multi-level dependencies live in 1 schema
Data never passes through a vendor backend: your own endpoint receives submissions and your own database or object storage holds all 3 data types - schemas, responses and attachments
Official packages ship TypeScript typings and localisation, surveys can switch between 50+ interface languages, and editors get field-level hints while coding

Cons 4 items

It is a library, not a finished SaaS: creation, publishing, permissions and reporting are all yours to build, which amounts to a small survey system
Commercial licensing for the creator and analytics is priced per developer seat, and at team scale the total approaches mature survey SaaS pricing
Large schemas are hard to read, running to hundreds of JSON lines, so changes need version control and regression tests
A Chinese interface can be switched on, but Chinese documentation and local support are thin, and edge cases are resolved through GitHub issues and English docs

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

Learning resources and tools

Visit SurveyJS Website → https://surveyjs.io/
Visit Website ↗