HTTP Column

HTTP Columns allow you to connect OttoGrid with external APIs, enabling real-time data fetching, validation, and integration. By dynamically pulling in data from external systems, HTTP Columns empower you to orchestrate workflows that combine OttoGrid's automation capabilities with third-party tools, external agents, and services.

Key Features

• Flexible API Support: Make GET, POST, PUT, DELETE, and PATCH requests.

• Dynamic Parameters: Reference column values using @ColumnName syntax for path, headers, query params, and body content.

• Secure Authentication: Use Bearer tokens, API keys, Basic Auth, or environment variables for sensitive data.

• Response Handling: Automatically parse JSON responses and handle errors or timeouts.

• Powerful Configuration: Define custom headers, query parameters, and request bodies for precise API calls.

How to Set Up an HTTP Column

Just like everything else, you can simply explain in natural language what you’d like your column to do to your ‘AI Chat’. You can simply describe what existing columns you want as your param inputs and what the endpoint to use is. However, here is a detailed guide on how to set it up manually or to better understand how this set up works!

1. Create an HTTP Column:

   • Set the column type to HTTP in your table configuration.

   • Add a descriptive column name (e.g., “Fetch User Data”).

2. Configure the API Request:

   • URL: Add the endpoint you want to call. You can include path variables using @ColumnName syntax.

   • Method: Select the HTTP method: GET, POST, PUT, DELETE, or PATCH.

   • Headers: Add key-value pairs for headers like Content-Type or Authorization. Reference variables using @ColumnName if needed.

   • Query Parameters: Add dynamic query strings to the URL. Example: ?email=@UserEmail.

   • Body (Optional): For POST, PUT, or PATCH requests, define the JSON payload. Include dynamic values using @ColumnName.

3. Secure Your API Calls:

   • Store sensitive data like API keys or tokens in Environment Variables under the Settings → API Keys page. Reference these variables in your configuration.

4. Handle the Response:

   • JSON responses are automatically parsed and returned to the column. Handle additional error responses as needed.

Example Configurations

1. Simple GET Request

Fetch user data from an external API using query parameters:

• URL: https://api.example.com/users

• Method: GET

• Headers:

  • Authorization: Bearer @APIToken

• Query Parameters:

  • email: @UserEmail

Response:
The API response (e.g., {"name": "John Doe", "age": 30}) will populate the HTTP column with the relevant data.

2. POST Request with a JSON Body

Send user information to an external service:

• URL: https://api.example.com/create

• Method: POST

• Headers:

  • Content-Type: application/json

• Body:

  {
    "user": "@UserName",
    "data": {
      "email": "@UserEmail",
      "type": "@UserType"
    }
  }

  Best Practices

  • Use Environment Variables: Never hardcode sensitive information like API keys. Use variables securely stored under Settings → API Keys.

  • Validate Dynamic Inputs: Ensure column values referenced using @ColumnName are accurate and well-structured.

  • Handle Errors Gracefully: Plan for API downtimes or rate limits by validating response status codes.

  Common Use Cases

  • Integration: Update CRMs, trigger external workflows, or sync with third-party services.

  • Form Submission Handling: Fetch responses submitted through forms (e.g., Typeform, Google Forms) and integrate them into your workflow.

  • Retrieve Private Data from Databases: Query private APIs or databases to pull secure information, such as user-specific details or transactional data.

  • Notifications: Push updates to tools like Slack, trigger emails, or send mobile alerts.

  Limitations and Considerations

  • Rate Limits: Ensure you comply with the rate limits of external APIs.

  • Column Dependencies: HTTP Columns depend on the order of columns in the table. Verify all input columns are correctly referenced.

  • Testing: Use Test Mode to verify HTTP column configurations before scaling up.

  Troubleshooting Tips

  • Invalid URL: Double-check URL formatting, dynamic parameters, and path variables.

  • Authentication Errors: Verify credentials or tokens stored in environment variables.

  • Incorrect JSON Body: Ensure your JSON structure is valid and dynamic references resolve correctly.

  • API Failures: Monitor API status codes, handle rate limiting, and validate response formats.

  Why Use HTTP Columns?

  HTTP Columns extend OttoGrid’s capabilities by enabling seamless integration with external systems. Whether you’re pulling real-time data, validating information, or orchestrating complex workflows, HTTP Columns empower you to connect and automate processes efficiently.