canonical: https://jentic.com/apis/halict.com/halict

# Halict API

The Halict API builds forms, reads their responses, and turns each response into a case a team can stage, tag, and follow up. It lets a backend list and create forms, read and update responses, move them through stages, add notes, and manage team members and webhook subscriptions. A separate generate operation builds a form from a single sentence, and webhook subscriptions let a system hear about a new response the moment it arrives.

## For AI agents

Build forms, read and update their responses, move responses through stages, add notes, generate a form from a sentence, and subscribe to webhooks for new responses.

## Scope

Does not handle payment collection, e-signatures, or survey analytics dashboards. Use for building forms and managing their responses and cases only.

## Capabilities

- Build and list forms, and read a single form's definition
- Read form responses and move them through stages
- Add notes to a response for team follow-up
- Generate a new form from a one-sentence description
- Subscribe to webhooks so an agent hears about a new response as it arrives

## Use cases

### Intake to Case Pipeline

An agent turns incoming form responses into actionable cases. It lists responses for a form, reads each one, moves it to the right stage, and adds a note for the person who will follow up. Because responses and their stages and notes are first-class resources, the agent can run an intake queue end to end without a human copying data between tools.

Example prompt: List responses for a form, move the newest response to the next stage, and add a note describing the follow-up

### AI Form Builder

An agent creates a ready-to-use form from a plain-language brief. It calls the generate operation with a sentence describing the questions, then reads the created form back to confirm its fields. This lets a team spin up a new intake or survey form from a description instead of building it field by field.

Example prompt: Call the form-generate operation with a sentence describing an intake form and return the id of the created form

### Real-Time Response Handling

An agent reacts to new submissions the moment they land. It subscribes to the response event, then reads the new response and routes it, instead of polling the form on a timer. Subscriptions are created and removed through the API, so the agent manages which events it listens for.

Example prompt: Subscribe to the new-response event for a form and confirm the subscription was created

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/forms` | List forms |
| POST | `/forms` | Create a form |
| GET | `/forms/{id}` | Get a form |
| GET | `/forms/{formId}/responses` | List responses for a form |
| POST | `/responses/{id}/notes` | Add a note to a response |
| POST | `/v1/forms/generate` | Build a form from a sentence |

## Key resources

- **Forms** — List, create, read, update, and delete forms
- **Responses** — List, read, update, and delete form responses, and add notes
- **Stages** — List the stages a form's responses can move through
- **Members** — List team members
- **Webhooks** — List, subscribe, and unsubscribe to response events
- **AI** — Generate a form from a single-sentence description

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 64 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 82 / 100
  - Developer Experience & Jentic Compatibility: 63 / 100
  - AI-Readiness & Agent Experience: 45 / 100
  - Agent Usability: 94 / 100
  - Security: 60 / 100
  - AI Discoverability: 70 / 100
- **View full report:** https://jentic.com/apis/halict.com/halict/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring Halict by hand means handling its bearer token, learning how responses move through stages, and polling or subscribing for new submissions. Through Jentic you install once, import Halict from the API Directory, store the token once, and your agent calls it.
- **Permission scoping:** Halict puts form and response ids in the URL path, so a rule can pin your agent to the response operations for one form. You choose the operations it may call, so destructive ones like form or response deletion are not included unless you add them.
- **Credential handling:** Your Halict token is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'build a form' or 'list form responses', and Jentic returns the matching Halict operation with its input schema so the agent calls the right endpoint without reading the reference docs.

## Related APIs

- **Typeform** — Typeform is a conversational form builder with a large template and integration library.
- **Jotform** — Jotform offers drag-and-drop forms with many field types and payment widgets.
- **Airtable** — Airtable stores and organises structured records that form responses can flow into.

## FAQ

### What authentication does the Halict API use?

Per its OpenAPI spec, the Halict API authenticates with a bearer token sent in the Authorization header. Through Jentic the token is stored by your own self-hosted instance and injected when the agent calls an operation, so it never appears in the agent's prompt or logs.

### Can I generate a form from text with the Halict API?

Yes. Halict exposes a generate operation that builds a form from a single-sentence description, so an agent can create an intake or survey form from a brief instead of defining each field. The agent can then read the form back to confirm its questions before sharing it.

### What are the rate limits for the Halict API?

The OpenAPI spec does not state a numeric rate limit. Add retry and backoff around 429 responses, and check the Halict documentation at https://halict.com for any published limits before running high-volume jobs.

### Can I limit what my agent is allowed to do with the Halict API?

Yes. Write a rule that allows the response read and note operations for one form id, so the agent can triage and annotate submissions while the form-delete and member operations stay out of reach, and every call it makes is logged. Halict carries form and response ids in the URL path, which is what makes that per-form boundary possible.

### Is there a Halict MCP server?

You do not need an MCP server to give your agent the Halict API. Jentic connects it directly from the Jentic API Directory: import Halict, store your token once, and your agent calls the form, response, and generate operations on demand without loading another server's tool definitions into its context.

### How do I handle form responses with the Halict API through Jentic?

Search Jentic by intent such as 'list form responses', and Jentic returns the Halict operation with its input schema so the agent reads and stages submissions. To run it on your own infrastructure, install Jentic One from its GitHub repo with `curl -fsSL https://raw.githubusercontent.com/jentic/jentic-one/main/tools/install.sh | sh`, then add Halict from the directory.