Export forms

Exports a form's responses as JSON or CSV, a page of up to 5000 at a time under the same filter a listing takes; next is the page to ask for after it, 0 at the end.

GET /v1/form/forms/{id}/export

Form → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/form/forms/{id}/export`
Method	`GET`
Operation	`export_form_responses`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Exports a form's responses as JSON or CSV, a page of up to 5000 at a time under the same filter a listing takes; next is the page to ask for after it, 0 at the end. The CSV has one column per field (its title), then each hidden value, the respondent's address and kind, and when the response was landed on and submitted. An org admin only.

Request

12 fields.

Field	In	Type	Required	Description
`id`	path	string	yes	ID is the form's id or slug, from the path.
`page`	query	integer	—	Page is the page, from 1.
`page_size`	query	integer	—	PageSize is how many a page holds: at most 1000, default 25.
`since`	query	string	—	Since keeps the responses made at or after it, RFC 3339.
`until`	query	string	—	Until keeps the responses made before it, RFC 3339.
`completed`	query	boolean	—	Completed keeps the completed responses (true) or the open ones (false); absent keeps both.
`query`	query	string	—	Query keeps the responses whose answers hold it.
`filed`	query	boolean	—	Filed keeps the responses on the CRM's timeline (true) or not yet on it (false); absent keeps both.
`sort`	query	string	—	Sort is submitted_at,desc (the default) or submitted_at,asc.
`included_response_ids`	query	string	—	IncludedResponseIDs keeps only these responses, comma separated, at most 90.
`excluded_response_ids`	query	string	—	ExcludedResponseIDs drops these responses, comma separated, at most 90.
`format`	query	string	—	Format is json (the default) or csv.

Response

Status	Body	Meaning
`200`	form.Export	ok
`default`	problem-details	refused

200 body — 38 fields.

Field	In	Type	Always	Description
`csv`	body	string	—	CSV is the responses as CSV, for csv: one row each, one column per field, then the hidden values, the respondent and the times.
`filename`	body	string	—	Filename is what to save it as.
`format`	body	string	—	Format is json or csv.
`items`	body	form.Response[]	—	Items are the responses, for json.
`items[].answers`	body	form.Answer[]	—	Answers are the answers, in the form's field order.
`items[].answers[].boolean`	body	boolean	—
`items[].answers[].choices`	body	string[]	—
`items[].answers[].date`	body	string	—
`items[].answers[].field`	body	string	—	Field is the ref of the field answered.
`items[].answers[].number`	body	number (double)	—
`items[].answers[].text`	body	string	—
`items[].answers[].type`	body	string	—	Type is the field's type.
`items[].completed`	body	boolean	—	Completed is whether the response was submitted whole; false is one saved part way.
`items[].created`	body	string	—	Created is when the record was first written, RFC 3339.
`items[].duration`	body	integer (int64)	—	Duration is how many seconds lay between landing and submitting.
`items[].external`	body	string	—	External is an imported response's id where it came from.
`items[].filed`	body	boolean	—	Filed is whether a completed response is on the CRM's timeline.
`items[].filing`	body	string	—	Filing is why the last filing failed; empty once it is filed.
`items[].form`	body	string	—	Form is the form's id.
`items[].hidden`	body	object	—	Hidden are the values the page passed in, by name.
`items[].hidden.*`	body	string	—
`items[].id`	body	string	—	ID is the response's id: derived from the form and the submission's token (from the form and the address on a subscribe form), so a retried submission is this same response.
`items[].landed_at`	body	string	—	LandedAt is when the respondent opened the form, RFC 3339, as their page said.
`items[].path`	body	string	—	Path is the page the form was answered on.
`items[].respondent`	body	form.Respondent	—
`items[].respondent.email`	body	string	—	Email is the address the response is from: the account's, else the email field's.
`items[].respondent.kind`	body	string	—	Kind is account (a signed-in person, from their token), email (an email field's answer), visitor (the page's visitor id) or none.
`items[].respondent.person_id`	body	string	—	PersonID is the CRM person the address is: the one key a response, a list membership, an email event and an experiment share.
`items[].respondent.subject`	body	string	—	Subject is the signed-in person's IAM subject.
`items[].respondent.verified`	body	boolean	—	Verified is whether the respondent is who the response says: true only for a signed-in person, from their token.
`items[].respondent.visitor`	body	string	—	Visitor is the page's visitor id.
`items[].source`	body	string	—	Source is web, or import for a response brought in from elsewhere.
`items[].submitted_at`	body	string	—	SubmittedAt is when the response was completed, RFC 3339.
`items[].token`	body	string	—	Token is the submission token the response was made under.
`items[].updated`	body	string	—	Updated is when it last changed, RFC 3339.
`next`	body	integer (int64)	—
`page`	body	integer (int64)	—	Page is this page; Next the page after it, 0 when this is the last.
`total`	body	integer (int64)	—	Total is how many responses answer the filter.

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo form forms export <id>

.ts

.py

.go

.rs

.java

import { Configuration, FormApi } from 'hanzoai';

const api = new FormApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.exportFormResponses({ id: 'id' });

from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import FormApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = FormApi(client).export_form_responses(id='id')

cfg := hanzoai.NewConfiguration()
cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY"))
client := hanzoai.NewAPIClient(cfg)

resp, _, err := client.FormAPI.ExportFormResponses(context.Background()).Execute()
if err != nil {
	return err
}

use hanzo_client::apis::{configuration::Configuration, form_api};

let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok();

let result = form_api::export_form_responses(&cfg, Default::default()).await?;

import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.FormApi;

ApiClient client = new ApiClient();
client.setBearerToken(System.getenv("HANZO_API_KEY"));

var result = new FormApi(client).exportFormResponses();

The method above is the one at the current release of the document. [email protected] (npm) and [email protected] (PyPI) were generated from an earlier release, where this operation carried a different id, so it spells the method differently — regenerating the clients is what makes the two agree. SDKs →

curl https://api.hanzo.ai/v1/form/forms/<id>/export \
  -H "Authorization: Bearer $HANZO_API_KEY"

Tool form, op export_form_responses — POST the JSON-RPC envelope to https://api.hanzo.ai/v1/mcp.

curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "form",
         "arguments": {
           "op": "export_form_responses",
           "input": {
             "id": "<id>"
           }
         }
       }
     }'

Form API · All Hanzo APIs · Interactive reference

Was this page useful?

Broken link or missing step? Drop it in #docs on Discord or open a PR.

PreviousDelete forms NextCreate file