Frequently Asked Questions

KirokuForms is the first form platform designed for today's intelligent world. We uniquely combine professional form building with cutting-edge AI workflow integration, serving both traditional business needs and emerging AI applications.

For Business Users: Create lightning-fast, fully customizable forms that work beautifully across all devices and platforms. Our dual rendering approach (HTML-only + JavaScript-enhanced) ensures maximum performance and compatibility.

For Developers: Enjoy complete API control, zero vendor lock-in, and performance-optimized solutions that integrate seamlessly with any tech stack.

For AI Developers: Leverage native Human-in-the-Loop (HITL) capabilities with Model Context Protocol (MCP) compliance and LangGraph integration for production AI systems.

KirokuForms stands apart from traditional form builders in several key ways:

🚄 Performance-First Design

• HTML-only option: Works without JavaScript for maximum speed and compatibility
• JavaScript-enhanced option: Advanced features without compromising performance
• Edge deployment: Global CDN ensures fast loading anywhere

🛠️ Developer-Friendly Approach

• Complete API control: Programmatic form management and data access
• Zero vendor lock-in: Export your data and forms at any time
• Framework agnostic: Works with React, Vue, Astro, static sites, and more

🤖 AI-Ready Architecture

• Native HITL support: Human-in-the-Loop workflows for AI systems
• MCP compliance: Standards-based AI integration
• LangGraph integration: Seamless AI agent workflows

KirokuForms serves three primary audiences, each with specific benefits:

👩‍💼 Business Users & Marketers

• Small business owners needing professional contact forms
• Marketing teams creating lead capture and conversion forms
• Agencies managing forms for multiple clients
• Anyone wanting beautiful forms without technical complexity

👨‍💻 Developers & Technical Teams

• Web developers building client websites and applications
• SaaS companies needing embedded form solutions
• Agencies requiring white-label, customizable solutions
• Performance-conscious developers using static site generators

🧠 AI Developers & Researchers

• AI engineers building LangGraph applications with human oversight
• Research institutions requiring human annotation workflows
• Companies deploying AI agents that need human feedback loops
• MLOps teams building production AI systems

No coding knowledge is required for basic form creation and management. Our visual form builder is designed for non-technical users and includes:

• Drag-and-drop field creation
• Point-and-click customization
• Pre-built templates for common use cases
• Simple copy-and-paste embedding

However, if you are technical, you'll appreciate our developer-friendly features:

• Complete REST API for programmatic control
• Webhook integrations for real-time data processing
• Custom CSS for unlimited styling possibilities
• Framework-specific integration guides

This dual approach means KirokuForms grows with your technical sophistication and team needs.

KirokuForms offers a comprehensive REST API for complete programmatic control:

📋 Form Management API

• Create, read, update, and delete forms
• Manage form fields and validation rules
• Configure form settings and styling
• Control form activation and publishing

📊 Submission Management API

• Retrieve submissions with filtering and pagination
• Export data in multiple formats (JSON, CSV, XML)
• Delete or archive submissions
• Real-time submission webhooks

🤖 AI Integration API

• Submit HITL tasks programmatically
• Retrieve task results and status
• Configure human review workflows
• MCP-compliant endpoints for AI systems

// Create a new form using the KirokuForms API
const response = await fetch('https://www.kirokuforms.com/api/forms', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer your-api-key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: 'Customer Feedback Form',
    fields: [
      {
        type: 'email',
        name: 'email',
        label: 'Email Address',
        required: true
      },
      {
        type: 'textarea',
        name: 'feedback',
        label: 'Your Feedback',
        required: true
      }
    ],
    settings: {
      submitButtonText: 'Send Feedback',
      successMessage: 'Thank you for your feedback!'
    }
  })
});

const form = await response.json();
console.log('Form created:', form.data.id);

KirokuForms' HTML-only implementation provides maximum performance and compatibility by using traditional form submission mechanics:

✨ Benefits of HTML-Only Approach

• Ultra-fast loading: No JavaScript bundle to download
• Maximum compatibility: Works on any browser, even with JavaScript disabled
• SEO-friendly: Search engines can fully understand your forms
• Accessibility first: Screen readers and assistive technologies work perfectly

🔄 How It Works

1. User fills out and submits the form
2. Browser sends POST request to KirokuForms endpoint
3. KirokuForms processes and stores the submission
4. User is redirected to your custom success page

<!-- Ultra-fast, JavaScript-free form -->
<form action="https://www.kirokuforms.com/api/f/your-form-id" method="POST">
  <div class="form-group">
    <label for="email">Email Address</label>
    <input type="email" name="email" id="email" required>
  </div>
  
  <div class="form-group">
    <label for="message">Message</label>
    <textarea name="message" id="message" required></textarea>
  </div>
  
  <!-- Optional: Redirect to custom success page -->
  <input type="hidden" name="_redirect" value="https://yoursite.com/thank-you">
  
  <button type="submit">Send Message</button>
</form>

<!-- Optional: Unobtrusive branding for free tier -->
<div class="kiroku-attribution">
  <a href="https://kirokuforms.com?ref=form" target="_blank">
    Powered by KirokuForms
  </a>
</div>

KirokuForms offers two implementation approaches, each optimized for different use cases:

<!-- Progressive enhancement: works with or without JS -->
<form data-kiroku-form="your-form-id" method="POST" 
      action="https://www.kirokuforms.com/api/f/your-form-id">
  <div class="form-group">
    <label for="email">Email Address</label>
    <input type="email" name="email" id="email" required>
    <div class="error-message" data-field="email"></div>
  </div>
  
  <div class="form-group">
    <label for="company">Company</label>
    <input type="text" name="company" id="company">
  </div>
  
  <button type="submit">
    <span class="button-text">Get Started</span>
    <span class="loading-spinner hidden">Sending...</span>
  </button>
  
  <!-- Success message container (filled by JS) -->
  <div class="success-message hidden"></div>
</form>

<!-- Load the enhancement script -->
<script async src="https://cdn.kirokuforms.com/js/form.js"></script>

KirokuForms integrates seamlessly with all modern JavaScript frameworks through multiple approaches:

⚛️ React Integration

Use our custom hook for easy React integration with full TypeScript support.

🟢 Vue.js Integration

Vue composables and components work perfectly with our API endpoints.

🚀 Framework-Agnostic Approach

For any framework, you can use our standard HTML approach and enhance with our JavaScript library for optimal compatibility.

import { useState, useEffect } from 'react';

const useKirokuForm = (formId) => {
  const [submitting, setSubmitting] = useState(false);
  const [success, setSuccess] = useState(false);
  const [error, setError] = useState(null);

  const submitForm = async (formData) => {
    setSubmitting(true);
    setError(null);
    
    try {
      const response = await fetch(`https://www.kirokuforms.com/api/f/${formId}`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(formData)
      });
      
      if (response.ok) {
        setSuccess(true);
      } else {
        throw new Error('Submission failed');
      }
    } catch (err) {
      setError(err.message);
    } finally {
      setSubmitting(false);
    }
  };

  return { submitForm, submitting, success, error };
};

// Usage in component
const ContactForm = () => {
  const { submitForm, submitting, success } = useKirokuForm('your-form-id');
  
  const handleSubmit = (e) => {
    e.preventDefault();
    const formData = new FormData(e.target);
    submitForm(Object.fromEntries(formData));
  };

  if (success) return <div>Thank you for your message!</div>;

  return (
    <form onSubmit={handleSubmit}>
      <input name="email" type="email" required />
      <textarea name="message" required></textarea>
      <button disabled={submitting}>
        {submitting ? 'Sending...' : 'Send Message'}
      </button>
    </form>
  );
};

Human-in-the-Loop (HITL) is a machine learning approach where human judgment is integrated into automated systems to improve accuracy, handle edge cases, and provide oversight for AI decision-making.

🔄 How KirokuForms HITL Works

1. AI System Encounters Decision Point: Your AI agent reaches a point requiring human judgment
2. Task Submission: AI submits a review task to KirokuForms with context and options
3. Dynamic Form Generation: KirokuForms creates a custom review form based on the task
4. Human Review: Qualified reviewers provide input through the generated form
5. Result Integration: KirokuForms returns the human decision to your AI system
6. Workflow Continuation: AI continues processing with human-validated information

🎯 Common HITL Use Cases

• Content Moderation: Human review of flagged content before publication
• Data Validation: Human verification of AI-extracted information
• Quality Control: Human assessment of AI-generated outputs
• Edge Case Handling: Human decisions for scenarios outside AI training
• Annotation & Labeling: Human creation of training data for model improvement

KirokuForms provides native LangGraph integration through our Python SDK, making it easy to add human oversight to your AI agent workflows.

📦 Installation & Setup

Install our LangGraph integration package and configure your API credentials.

🔧 Integration Steps

1. Install the KirokuForms LangGraph package
2. Configure your API credentials
3. Add interrupt points in your LangGraph workflow
4. Submit HITL tasks when human input is needed
5. Resume workflow with human-provided decisions

from langgraph import Graph
from langgraph_kirokuforms import KirokuHITL
import os

# Initialize KirokuForms HITL integration
hitl = KirokuHITL(
    api_key=os.getenv('KIROKU_API_KEY'),
    base_url='https://www.kirokuforms.com/api'
)

def content_review_node(state):
    """Node that requires human review for content approval"""
    content = state.get('generated_content')
    
    # Check if content needs human review
    if requires_human_review(content):
        # Submit HITL task for human review
        task_result = hitl.submit_review_task(
            task_type='content_review',
            data={
                'content': content,
                'context': state.get('context'),
                'urgency': 'high'
            },
            form_template={
                'title': 'Content Review Required',
                'fields': [
                    {
                        'type': 'radio',
                        'name': 'approval',
                        'label': 'Content Approval',
                        'options': [
                            {'label': 'Approve as-is', 'value': 'approve'},
                            {'label': 'Approve with edits', 'value': 'approve_edit'},
                            {'label': 'Reject - needs revision', 'value': 'reject'}
                        ],
                        'required': True
                    },
                    {
                        'type': 'textarea',
                        'name': 'feedback',
                        'label': 'Reviewer Comments',
                        'placeholder': 'Provide specific feedback or requested changes...'
                    }
                ]
            },
            callback_url='https://your-app.com/hitl-webhook'
        )
        
        # LangGraph will pause here until human input is received
        return {'status': 'pending_review', 'task_id': task_result['task_id']}
    
    return {'status': 'approved', 'content': content}

# Create LangGraph workflow
workflow = Graph()
workflow.add_node('content_review', content_review_node)
workflow.add_edge('content_review', 'publish_content')

# Configure interrupt for HITL
workflow.add_interrupt('content_review')

# Run workflow - will pause at human review points
result = workflow.run(initial_state)

Model Context Protocol (MCP) is an emerging standard for connecting AI systems with external tools and services. KirokuForms provides full MCP compliance for seamless AI integration.

🔌 MCP Integration Benefits

• Standards Compliance: Works with any MCP-compatible AI system
• Future-Proof: Protocol evolution automatically supported
• Interoperability: Mix and match with other MCP tools
• Simplified Setup: No custom integration code required

from mcp_client import MCPClient
from kirokuforms_mcp import KirokuMCPServer

# Initialize KirokuForms MCP server
server = KirokuMCPServer(
    api_key='your-kiroku-api-key',
    config={
        'hitl_enabled': True,
        'auto_form_generation': True,
        'webhook_url': 'https://your-app.com/mcp-webhook'
    }
)

# Connect MCP client to KirokuForms
client = MCPClient()
client.connect_to_server(server)

# Submit HITL task via MCP
task = client.call_tool('kiroku_submit_hitl', {
    'task_type': 'data_validation',
    'data': {
        'extracted_info': {
            'name': 'John Doe',
            'email': 'john@example.com',
            'confidence': 0.87
        },
        'source_document': 'contract_v2.pdf'
    },
    'review_instructions': 'Please verify the extracted contact information is accurate'
})

print(f"HITL task submitted: {task['task_id']}")

# Check task status
status = client.call_tool('kiroku_get_task_status', {
    'task_id': task['task_id']
})

print(f"Task status: {status['status']}")
if status['status'] == 'completed':
    print(f"Human review result: {status['result']}")

KirokuForms provides multiple ways to submit HITL tasks programmatically, from simple REST API calls to framework-specific SDKs.

🔄 Task Submission Methods

• REST API: Direct HTTP requests for any programming language
• Python SDK: Native Python integration with type hints
• Node.js SDK: JavaScript/TypeScript integration
• MCP Protocol: Standards-based integration for AI systems

📊 Task Management Features

• Priority queue management for urgent tasks
• Task assignment to specific reviewer groups
• Deadline and expiration handling
• Progress tracking and status updates
• Result retrieval and webhook notifications

from kirokuforms import KirokuClient
import asyncio

# Initialize client
client = KirokuClient(api_key='your-api-key')

async def submit_review_task():
    # Submit a complex review task
    task = await client.hitl.submit_task(
        task_type='document_review',
        priority='high',
        expires_in='24h',
        data={
            'document_url': 'https://storage.example.com/contract.pdf',
            'ai_summary': 'Standard service agreement with non-standard clause 15',
            'confidence_score': 0.73,
            'flagged_sections': ['clause_15', 'payment_terms']
        },
        form_config={
            'title': 'Legal Document Review',
            'description': 'AI has flagged potential issues in this contract.',
            'fields': [
                {
                    'type': 'radio',
                    'name': 'overall_assessment',
                    'label': 'Overall Document Assessment',
                    'options': [
                        {'label': 'Approve - standard terms', 'value': 'approve'},
                        {'label': 'Approve with minor revisions', 'value': 'approve_revise'},
                        {'label': 'Escalate to senior counsel', 'value': 'escalate'},
                        {'label': 'Reject - major issues found', 'value': 'reject'}
                    ],
                    'required': True
                },
                {
                    'type': 'textarea',
                    'name': 'specific_concerns',
                    'label': 'Specific Concerns or Required Changes',
                    'placeholder': 'Detail any issues found in the flagged sections...'
                }
            ]
        },
        callbacks={
            'webhook_url': 'https://your-app.com/hitl-results',
            'email_notifications': ['legal@company.com']
        }
    )
    
    print(f"Task submitted successfully: {task.task_id}")
    return task

# Run the task submission
task = asyncio.run(submit_review_task())

# Check task status
status = await client.hitl.get_task_status(task.task_id)
if status.status == 'completed':
    result = await client.hitl.get_task_result(task.task_id)
    print(f"Review decision: {result.data['overall_assessment']}")

KirokuForms is designed for maximum performance across all metrics that matter for modern web applications:

⚡ Performance Benchmarks

🌐 Global Performance

• Edge Deployment: Forms served from 200+ global locations
• CDN Optimization: Static assets cached at edge for instant loading
• Smart Routing: Submissions processed at nearest data center
• 99.99% Uptime: Reliable performance when you need it most

Yes! KirokuForms forms work perfectly without JavaScript, making them the most compatible and accessible forms available:

✅ Complete Functionality Without JavaScript

• Form Submission: Standard HTTP POST works universally
• Validation: Server-side validation ensures data integrity
• User Feedback: Success/error pages provide clear status
• File Uploads: Traditional file upload mechanism supported
• Redirects: Custom success pages maintain user flow

🌍 Universal Browser Support

♿ Accessibility Excellence

• Screen Readers: Perfect compatibility with all assistive technologies
• Keyboard Navigation: Complete keyboard accessibility
• High Contrast: Supports high contrast and dark mode
• Text Scaling: Works perfectly at 200%+ zoom levels

KirokuForms offers one of the most generous free plans in the industry, perfect for small businesses and personal projects:

🆓 Free Plan Features

• 10 Forms: Create up to 10 different forms
• 500 Submissions/month: Generous submission allowance
• All Field Types: Text, email, file uploads, and more
• Basic Customization: Custom styling and branding options
• Email Notifications: Get notified of new submissions
• CSV Export: Download your data anytime
• Webhook Support: Integrate with external services
• Spam Protection: Built-in honeypot and rate limiting

AI integration features are available across different plan tiers, designed to scale with your usage and needs:

🤖 AI Features by Plan

Branding options depend on your subscription tier, with full white-labeling available for business users:

🏷️ Branding by Plan Tier

KirokuForms offers significant advantages over Typeform, especially for performance-conscious users and developers:

KirokuForms makes migration simple with tools and support to help you switch quickly:

🛠️ Migration Tools & Process

1. Form Recreation: Use our form builder to recreate your existing forms (usually 5-10 minutes per form)
2. Data Export: Export your existing submission data from your current provider
3. Data Import: Upload your historical data to KirokuForms (Business plan feature)
4. Update Embed Codes: Replace old form codes with new KirokuForms codes
5. Test & Launch: Verify everything works correctly before going live

🎯 Migration Support

• Free Migration Assistance: Our team helps recreate your forms
• Data Import Service: We'll import your historical data (Business plan)
• Integration Setup: Help configuring webhooks and integrations
• Testing Support: Verification that everything works correctly

Security is a foundational priority for KirokuForms, with comprehensive protection across all plan tiers:

🔒 Core Security (All Plans)

• Encryption in Transit: All data encrypted with TLS 1.3
• Encryption at Rest: Database-level encryption with AES-256
• Spam Protection: Honeypot fields and rate limiting
• Input Validation: Server-side validation and sanitization
• Secure Headers: HSTS, CSP, and other security headers

🏢 Business Security Features

• Domain Validation: Restrict form usage to verified domains
• IP Allowlisting: Limit submissions to specific IP ranges
• Advanced Rate Limiting: Sophisticated abuse prevention
• Audit Logs: Complete activity tracking and monitoring
• SOC 2 Compliance: Independent security certification

We provide comprehensive support across multiple channels, with response times that scale with your plan:

📧 Support Channels

Contact us at support@kirokuforms.com or use our contact form for any questions.

Yes, KirokuForms is designed with GDPR compliance as a core requirement, providing all necessary tools and features for EU data protection compliance:

⚖️ Legal Framework

• Data Processing Agreement (DPA): Available for all business customers
• Privacy Policy: Transparent data handling practices
• Terms of Service: Clear data controller/processor responsibilities
• Lawful Basis Documentation: Support for documenting legal basis for processing

🛠️ GDPR Compliance Tools

• Data Subject Requests: Tools to handle access, portability, and deletion requests
• Consent Management: Form-level consent tracking and management
• Data Export: Easy export of all personal data
• Data Deletion: Complete data removal with verification
• Processing Records: Automatic logging for compliance documentation