KinoForms
Start

Schema-backed forms

Agentic data schema forms

Start with a schema that defines the data you need. KinoForms connects form fields and structured response validation, with visual editing for people and documented create and diff-edit API interfaces for developers and coding agents.

Start buildingSign in

Problem

Give collected data a shared contract

A free-text answer can leave a workflow guessing which values belong where. A form schema names the fields, their types, and their requirements so people and integrations can work toward the same structured response.

The native KinoForms schema

KinoForms uses a JSON form definition with a fields array. Each field has an identifier and type, with labels, requiredness, and supported constraints. The visual builder edits this form definition; documented API requests create a draft or change specific fields.

  • Field IDs connect form definitions to response values
  • Field types and constraints guide response validation
  • Ordered operations express small, explicit form edits
  • Conditional rules support the respondent path

Documented create and edit requests

These request bodies use the native KinoForms format. Send them to the dashboard API with Content-Type: application/json and an x-api-key header carrying forms:write access. Use the returned data.form.id as the form_id for the edit request.

Create a draft from a native schema

POST /papi/v1/management/forms

{
  "name": "Contact intake",
  "schema": {
    "fields": [
      {
        "id": "email",
        "type": "email",
        "label": "Email",
        "required": true
      }
    ]
  }
}

Edit fields with an ordered diff

PATCH /papi/v1/management/forms/{form_id}

{
  "operations": [
    {
      "op": "updateField",
      "fieldId": "email",
      "set": {
        "label": "Work email"
      }
    },
    {
      "op": "addField",
      "field": {
        "id": "phone",
        "type": "phone",
        "label": "Phone"
      }
    }
  ]
}

These examples describe the documented interfaces. Read the Builder Guide for response envelopes, PATCH errors, and the limits of expectedVersion. Creating or editing a draft is separate from publishing it.

Builder GuidePublic OpenAPI contractStructured validation referencePublic Forms user guide

Where this page fits

Use a shared schema when collection needs named fields, predictable types, and a clear handoff from editing to validation.

Contact intake with named email and phone fields
Coding-agent workflows that prepare a draft form request
Human review of a form schema before collection
Structured responses checked before submission

How the workflow moves

Define the form in the visual builder, or start with the documented API examples and review the native schema before collecting responses.

1

Define the fields

Choose field IDs, types, labels, and required values in the visual builder or prepare a name/schema request using the documented create interface.

2

Review and edit the draft

Use the visual editor or prepare ordered PATCH operations. Read the current form before editing; expectedVersion checks the published version and does not detect another draft edit.

3

Validate structured responses

Response validation checks supplied values against the form's field rules. The documented validation interface returns structured field details when validation fails, so an integration can inspect the problem and prepare a corrected request.

What this looks like in a form

One field ID from form to response

An email field named email connects the form definition to an email value in response data. Requiredness and field type give validation a concrete contract to check.

An explicit diff instead of a full replacement

An updateField operation can change a label while an addField operation adds a phone field. Operations apply in order and persist together only if they succeed.

Follow the connected form workflow

form submission validation

Understand required fields, constraints, and conditional validation.

conditional logic

Guide the respondent path with rules that show, hide, require, and filter fields.

form analytics

Review collection activity and completion patterns after the form is in use.

Common questions

What does agentic data schema forms mean here?

It means working from an explicit form schema across human editing and coding-agent request preparation. KinoForms provides the visual builder and documents API interfaces for draft creation, diff-based editing, and structured response validation.

Is the native form schema interchangeable with arbitrary JSON Schema?

KinoForms uses its own form definition, including schema.fields entries. The examples on this page use that native format; they do not establish import or compatibility with arbitrary JSON Schema documents.

Do the create and edit examples publish a form?

The documented create request produces a draft, and PATCH edits the form. Publishing is a separate workflow. Use the Builder Guide for these request shapes and the Public Forms user guide for human publishing.

How do collection and review fit?

Conditional logic guides which fields a respondent sees. Controlled collection, templates, submission review, and analytics support the workflow around the schema and its validated response data.

Build from the data you need

Define the form in the visual builder, or start with the documented API examples and review the native schema before collecting responses.

Start building