Skip to content

HTTP Request Node Documentation

Overview

The HTTP Request node enables integration with external APIs and services by sending HTTP requests (GET, POST, PUT, PATCH, DELETE) to third-party systems. This node is essential for connecting your workflows to external data sources, webhooks, and RESTful APIs.

Configuration

Required Fields

  • Connector: Select a pre-configured connector that handles authentication and base configuration for the target service
  • URL: The endpoint URL for the HTTP request (supports dynamic variables)
  • Method: HTTP method for the request:
  • GET: Retrieve data from the server
  • POST: Send data to create new resources
  • PUT: Update existing resources completely
  • PATCH: Partially update existing resources
  • DELETE: Remove resources from the server
  • Response Type: Expected format of the response:
  • JSON: Structured data response (most common for APIs)
  • Text: Plain text response

Optional Fields

  • Request Body: Data to send with POST, PUT, and PATCH requests (supports JSON formatting and workflow variables)

Advanced Configuration

  • JSON Configuration: Direct JSON editing for complex request configurations including headers, authentication parameters, and advanced options

Use Cases

1. Data Synchronization

  • CRM Integration: Sync customer data with external CRM systems
  • Database Updates: Push processed data to external databases
  • Inventory Management: Update stock levels in e-commerce platforms

Example Configuration:

Method: POST
URL: /api/customers
Body: {
  "name": "{{resullt.customer_name}}",
  "email": "{{resullt.customer_email}}",
  "status": "{{resullt.status}}"
}
Response Type: JSON

2. External Service Integration

  • Payment Processing: Send payment requests to payment gateways
  • Notification Services: Trigger SMS, email, or push notifications
  • Analytics Tracking: Send event data to analytics platforms

Example Configuration:

Method: POST
URL: /api/v1/events
Body: {
  "event_type": "workflow_completed",
  "user_id": "{{result.user_id}}",
  "metadata": "{{result.workflow_results}}"
}
Response Type: JSON

3. Webhook Triggers

  • Third-Party Notifications: Notify external systems of workflow completion
  • Automation Triggers: Start processes in external systems
  • Status Updates: Send progress updates to monitoring systems

Example Configuration:

Method: POST
URL: {{webhook_url}}
Body: {
  "status": "completed",
  "workflow_id": "{{result.workflow_id}}",
  "timestamp": "{{result.current_timestamp}}"
}
Response Type: Text

4. Data Enrichment

  • External Lookups: Fetch additional data from external APIs
  • Validation Services: Verify data against external databases
  • Geocoding: Convert addresses to coordinates using mapping APIs

Example Configuration:

Method: GET
URL: /api/geocode?address={{address}}
Response Type: JSON

5. System Integration

  • ERP Systems: Update business records in enterprise systems
  • Document Management: Store processed documents in document systems
  • Reporting Systems: Send data to business intelligence platforms

Integration Patterns

Sequential API Calls

Start → HTTP Request (Get Data) → Process → HTTP Request (Update) → End

Conditional API Integration

Start → Analysis → Gateway → [HTTP Request (Success) | HTTP Request (Error)] → End

Parallel Service Integration

Start → Parallel Gateway → [HTTP Request (Service A) | HTTP Request (Service B)] → End

Error Handling with Retry

Start → HTTP Request → Gateway → [Success Path | Retry Logic → HTTP Request] → End

Authentication and Security

Connector-Based Authentication

  • API Keys: Secure storage and automatic inclusion in requests
  • OAuth Tokens: Managed token refresh and authentication flows
  • Basic Authentication: Username/password authentication
  • Bearer Tokens: JWT and other token-based authentication

Security Best Practices

  • Credential Management: Never hardcode credentials in workflow configurations
  • HTTPS Only: Always use encrypted connections for sensitive data
  • Rate Limiting: Respect external API rate limits
  • Data Validation: Validate responses before using in subsequent steps

Response Handling

JSON Responses

  • Automatically parsed into workflow variables
  • Supports nested object access using dot notation
  • Enables direct field extraction for subsequent nodes

Text Responses

  • Raw text content stored as workflow variable
  • Suitable for simple API responses, status messages, or non-structured data
  • Can be further processed by AI nodes if needed

Error Responses

  • HTTP error codes automatically captured
  • Error messages included in workflow execution logs
  • Supports conditional handling based on response status

Advanced Features

Dynamic URL Construction

  • Use workflow variables in URL paths and query parameters
  • Support for complex URL patterns with multiple variables
  • Query parameter encoding handled automatically

Request Body Templating

  • JSON body construction with workflow variables
  • Support for nested objects and arrays
  • Automatic data type handling and conversion

Response Data Mapping

  • Extract specific fields from API responses
  • Transform response data for use in subsequent nodes
  • Support for complex JSON path expressions

Best Practices

1. Connector Configuration

  • Centralized Management: Use connectors for shared authentication and base URLs
  • Environment Separation: Separate connectors for development, staging, and production
  • Permission Management: Use least-privilege principles for API access

2. Error Handling

  • Status Code Checking: Implement logic to handle different HTTP status codes
  • Retry Logic: Add retry mechanisms for transient failures
  • Timeout Configuration: Set appropriate timeouts for external service calls
  • Fallback Strategies: Define alternative actions when external services are unavailable

3. Performance Optimization

  • Request Batching: Group multiple operations when APIs support batch requests
  • Caching: Cache frequently accessed data to reduce API calls
  • Async Processing: Use parallel processing for independent API calls
  • Rate Limit Management: Implement delays to respect API rate limits

4. Data Security

  • Input Validation: Validate data before sending to external APIs
  • Output Sanitization: Clean and validate responses from external services
  • Sensitive Data Handling: Avoid logging sensitive information
  • Compliance: Ensure API integrations meet regulatory requirements

5. Monitoring and Debugging

  • Request Logging: Monitor API calls for debugging and optimization
  • Response Validation: Verify response formats and content
  • Performance Metrics: Track response times and success rates
  • Alert Configuration: Set up notifications for integration failures

Limitations

API Constraints

  • Rate Limits: Subject to external API rate limiting policies
  • Request Size: Limited by external API payload size restrictions
  • Timeout Limits: Bounded by network and service response times
  • Authentication: Dependent on external service authentication methods

Network Dependencies

  • Internet Connectivity: Requires stable network connection
  • Service Availability: Dependent on external service uptime
  • Latency: Response times affected by network and service performance
  • Firewall Restrictions: May require network configuration for enterprise deployments

Data Format Limitations

  • Response Parsing: Limited to JSON and text response types
  • Complex Data Structures: May require additional processing for complex formats
  • Binary Data: Not optimized for binary file uploads or downloads
  • Character Encoding: Assumes UTF-8 encoding for text responses

Troubleshooting

Common Issues

  1. Authentication Failures: Verify connector credentials and permissions
  2. 404 Not Found: Check URL construction and endpoint availability
  3. Timeout Errors: Increase timeout settings or optimize external service performance
  4. Rate Limiting: Implement delays or reduce request frequency
  5. JSON Parsing Errors: Verify response format matches expected JSON structure

Debugging Techniques

  • Test External APIs: Verify API endpoints work outside of workflows
  • Check Connector Status: Ensure connectors are properly configured and active
  • Validate Request Data: Verify request body format and required fields
  • Monitor Network: Check for network connectivity and firewall issues
  • Review API Documentation: Confirm API usage matches provider specifications

Performance Troubleshooting

  • Monitor request/response times for performance bottlenecks
  • Use workflow execution logs to identify slow API calls
  • Implement caching for frequently accessed data
  • Consider parallel processing for independent API operations
  • Review external service performance and status pages