Jotform API Getting Started: Quickstart Guide (2026)

Getting started overview

Integrating with the Jotform API allows developers to programmatically interact with Jotform accounts, managing forms, submissions, users, and reports. This guide covers the essential steps to get started: account creation, API key generation, and executing a foundational API request. The Jotform API is a RESTful interface, primarily communicating via HTTP methods (GET, POST, PUT, DELETE) and returning JSON responses, a common practice for web APIs as defined by the W3C JSON-LD 1.1 specification. This structure facilitates integration across various programming environments.

The API provides endpoints for:

• Form Management: Creating, retrieving, updating, and deleting forms.
• Submission Handling: Accessing, adding, and modifying form submissions.
• User Data: Retrieving information about the authenticated user.
• Report Generation: Interacting with form reports.

Before making any requests, an API key is required for authentication. This key links your application to your Jotform account and its associated permissions. Understanding how to locate your Jotform API key is a critical first step.

Here is a quick reference table outlining the getting started process:

Create an account and get keys

To begin using the Jotform API, you must first have an active Jotform account. If you do not already have one, you can register for a free Jotform Starter plan, which includes access to the API with certain usage limits (e.g., 5 forms, 100 submissions per month). For higher limits or advanced features, paid plans are available, starting with the Bronze tier.

Account Creation

1. Navigate to the Jotform Sign Up page.
2. Enter your email address and create a password, or sign up using your Google or Facebook account.
3. Follow any on-screen prompts to complete the registration process.

Generating Your API Key

After creating and logging into your Jotform account, you can generate or locate your API key. This key is crucial for authenticating your API requests.

1. Log in to your Jotform account.
2. Go to your My Account API page.
3. Under the 'API Keys' section, you will see a list of your existing API keys. If you don't have one, or wish to create a new one, click the 'Create New Key' button.
4. Jotform API keys have different permission levels:
• Full Access: Allows all operations (read, write, delete). Use with caution.
• Read Only: Allows data retrieval only.
• Submission Write: Allows creating and updating submissions.
• Form Edit: Allows creating and updating forms.
5. Select the appropriate permission level for your application. For initial testing, 'Read Only' is often sufficient and recommended for security best practices.
6. Copy the generated API key. Keep this key secure, as it grants access to your Jotform data. Treat it like a password.

Your first request

Once you have your API key, you can make your first authenticated request to the Jotform API. A common initial request is to retrieve information about the authenticated user, which confirms your API key is valid and correctly configured.

API Base URL

All Jotform API requests should be sent to the base URL: https://api.jotform.com

Endpoint for User Information

To get user details, you will use the /user endpoint.

Endpoint: GET /user

Constructing the Request

The API key is passed as a query parameter named apiKey.

Example using cURL:

curl -X GET "https://api.jotform.com/user?apiKey=YOUR_API_KEY"

Replace YOUR_API_KEY with the API key you generated from your Jotform account.

Example using Python (with requests library):

import requests

api_key = "YOUR_API_KEY"
base_url = "https://api.jotform.com"

url = f"{base_url}/user"
params = {"apiKey": api_key}

response = requests.get(url, params=params)

if response.status_code == 200:
    user_data = response.json()
    print("Successfully retrieved user data:")
    print(user_data)
else:
    print(f"Error: {response.status_code} - {response.text}")

Example using JavaScript (Node.js with node-fetch):

const fetch = require('node-fetch');

const apiKey = "YOUR_API_KEY";
const baseUrl = "https://api.jotform.com";

async function getUserData() {
    const url = `${baseUrl}/user?apiKey=${apiKey}`;
    try {
        const response = await fetch(url);
        const data = await response.json();
        if (response.ok) {
            console.log("Successfully retrieved user data:");
            console.log(data);
        } else {
            console.error(`Error: ${response.status} - ${data.message || response.statusText}`);
        }
    } catch (error) {
        console.error("Fetch error:", error);
    }
}

getUserData();

Expected Response

A successful response (HTTP status 200 OK) will return a JSON object containing details about your Jotform user account, such as:

{
  "responseCode": 200,
  "message": "success",
  "content": {
    "username": "your_username",
    "email": "[email protected]",
    "name": "Your Name",
    "usage": "100",
    "limit": "10000",
    "plan": "FREE",
    "account_type": "Free",
    "isVerified": "1",
    "lastLogin": "2026-05-29 10:00:00"
    // ... more user details
  },
  "duration": "0.045"
}

Common next steps

After successfully making your first API call, consider these next steps to further your integration:

• Explore Other Endpoints: Review the Jotform API documentation to understand the full range of available endpoints for managing forms (/user/forms), submissions (/form/{id}/submissions), and other resources.
• Create a Form Programmatically: Try creating a new form using the POST /user/forms endpoint. This demonstrates the API's write capabilities.
• Retrieve Form Submissions: Access data collected through your forms using the GET /form/{id}/submissions endpoint. You will need a form ID, which you can find from your Jotform account or by querying the /user/forms endpoint.
• Implement Error Handling: Develop robust error handling in your application. The API returns various HTTP status codes (e.g., 400 Bad Request, 401 Unauthorized, 404 Not Found) and error messages in the JSON response to indicate issues.
• Secure Your API Key: Ensure your API key is not hardcoded in client-side code or publicly exposed. For server-side applications, use environment variables or a secure configuration management system. For client-side interactions, consider using a backend proxy or serverless functions to mediate API calls.
• Monitor Usage: Keep track of your API usage against your plan limits to avoid unexpected interruptions. Your account dashboard provides insights into your current usage.
• Explore Webhooks: For real-time updates when a form is submitted, consider setting up Jotform webhooks. This push-based mechanism is often more efficient than polling the API for new submissions. Webhooks are a common pattern in API design, described further in sources like the Mozilla Developer Network's WebHook API overview.

Troubleshooting the first call

Encountering issues during your first API call is common. Here are some troubleshooting steps:

• Check API Key: Double-check that the API key in your request exactly matches the key generated in your Jotform My Account API page. Even minor typos can cause authentication failures.
• Verify Permissions: Ensure your API key has the necessary permissions for the endpoint you are trying to access. For the /user endpoint, a 'Read Only' key is sufficient. If you get a 401 Unauthorized or 403 Forbidden error for other endpoints, check if the key has 'Full Access' or specific 'Write' permissions if you're modifying data.
• Incorrect Endpoint URL: Confirm that the base URL (https://api.jotform.com) and the specific endpoint path (e.g., /user) are correct. Refer to the Jotform API documentation for exact endpoint paths.
• Missing Query Parameter: Ensure the API key is passed as a query parameter named apiKey (e.g., ?apiKey=YOUR_API_KEY).
• Network Issues: Check your internet connection. If you are behind a corporate firewall, ensure that requests to api.jotform.com are not being blocked.
• Rate Limits: While less likely for a first call, be aware that Jotform imposes API rate limits. If you are testing repeatedly in a short period, you might temporarily hit a limit, resulting in a 429 Too Many Requests error. Wait a few moments before retrying.
• Review Error Messages: The JSON response for an unsuccessful request often contains a message field with details about the error. Read these messages carefully, as they can directly point to the problem.
• Inspect HTTP Status Codes: The HTTP status code provides a quick indication of the problem:
• 400 Bad Request: Often indicates malformed request, missing required parameters.
• 401 Unauthorized: API key is missing or invalid.
• 403 Forbidden: API key lacks necessary permissions for the requested action.
• 404 Not Found: Endpoint URL is incorrect or the resource does not exist.
• 500 Internal Server Error: Indicates an issue on Jotform's side.