Skip to main content

HTTP

The HTTP task is used to make calls to remote services exposed over HTTP/HTTPS. It supports various HTTP methods, headers, body content, and other configurations needed for interacting with APIs or remote services.

The HTTP task evaluates the parameters provided, constructs the HTTP request accordingly, and sends it to the specified URI. It handles the response by extracting useful information like status code, headers, and body content, which can be used in subsequent tasks in the workflow.

Task parameters

Configure these parameters for the HTTP task.

ParameterDescriptionRequired/ Optional
inputParameters.uriThe URI for the service. It can be a partial value when using vipAddress or it can be the server address.Required.
inputParameters.methodThe HTTP method. Supported methods:
  • GET
  • HEAD
  • POST
  • PUT
  • PATCH
  • DELETE
  • OPTIONS
  • TRACE
Required.
inputParameters.acceptThe accept header required by the server. The default value is application/json. Supported types:
  • application/java-archive
  • application/EDI-X12
  • application/EDIFACT
  • application/javascript
  • application/octet-stream
  • application/ogg
  • application/pdf
  • application/xhtml+xml
  • application/x-shockwave-flash
  • application/json
  • application/ld+json
  • application/xml
  • application/zip
  • application/x-www-form-urlencoded
  • audio/mpeg
  • audio/x-ms-wma
  • audio/vnd.rn-realaudio
  • audio/x-wav
  • image/gif
  • image/jpeg
  • image/png
  • image/tiff
  • image/vnd.microsoft.icon
  • image/x-icon
  • image/vnd.djvu
  • image/svg+xml
It can be passed as a dynamic input.
Optional.
inputParameters.contentTypeThe content type for the server. The default value is application/json. Supported types:
  • application/java-archive
  • application/EDI-X12
  • application/EDIFACT
  • application/javascript
  • application/octet-stream
  • application/ogg
  • application/pdf
  • application/xhtml+xml
  • application/x-shockwave-flash
  • application/json
  • application/ld+json
  • application/xml
  • application/zip
  • application/x-www-form-urlencoded
  • audio/mpeg
  • audio/x-ms-wma
  • audio/vnd.rn-realaudio
  • audio/x-wav
  • image/gif
  • image/jpeg
  • image/png
  • image/tiff
  • image/vnd.microsoft.icon
  • image/x-icon
  • image/vnd.djvu
  • image/svg+xml
It can be passed as a dynamic input.
Optional.
inputParameters.hedgingConfig.maxAttemptsThe maximum number of parallel requests to send. The system will use the response from the first successful attempt, helping reduce tail latencies in remote services.
Note: Hedging makes parallel requests, so use it only for idempotent services.
Optional.
inputParameters.headersA map of additional HTTP headers to be sent along with the request. Supported types:
  • Accept-Language
  • Authorization
  • Cache Control
  • Content-MD5
  • From
  • If-Match
  • If-Modified-Since
  • If-None-Match
  • Max-Forwards
  • Pragma
  • If-Range
  • If-Unmodified-Since
  • Proxy-Authorization
  • Range
  • Warning
  • x-api-key
  • Accept-Charset
  • Accept-Encoding
  • Accept-Control-Request-Headers
  • Accept-Control-Request-Method
  • Content-Transfer-Encoding
  • Expect
  • Transfer-Encoding
  • Trailer
Optional.
inputParameters.bodyThe request body for POST, PUT, or PATCH methods. Can be text or parameters such as string, number, boolean, null, or object/array.Required for POST, PUT, or PATCH.
inputParameters.encodeDetermines whether the URI needs encoding. When set to true, the Conductor will automatically encode the query parameters before sending the HTTP request. Set this to false if the URI is already encoded. The default value is true.Optional.

Caching parameters

You can cache the task outputs using the following parameters. Refer to Caching Task Outputs for a full guide.

ParameterDescriptionRequired/ Optional
cacheConfig.ttlInSecondThe time to live in seconds, which is the duration for the output to be cached.Required if using cacheConfig.
cacheConfig.keyThe cache key is a unique identifier for the cached output and must be constructed exclusively from the task’s input parameters.
It can be a string concatenation that contains the task’s input keys, such as ${uri}-${method} or re_${uri}_${method}.
Required if using cacheConfig.

Schema parameters

You can enforce input/output validation for the task using the following parameters. Refer to Schema Validation for a full guide.

ParameterDescriptionRequired/ Optional
taskDefinition.enforceSchemaWhether to enforce schema validation for task inputs/outputs. Set to true to enable validation.Optional.
taskDefinition.inputSchemaThe name and type of the input schema to be associated with the task.Required if enforceSchema is set to true.
taskDefinition.outputSchemaThe name and type of the output schema to be associated with the task.Required if enforceSchema is set to true.

Other generic parameters

Here are other parameters for configuring the task behavior.

ParameterDescriptionRequired/ Optional
optionalWhether the task is optional. The default is false.

If set to true, the workflow continues to the next task even if this task is in progress or fails.
Optional.
asyncCompleteWhether the task is completed asynchronously. The default value is false.
  • false—Task status is set to COMPLETED upon successful execution.
  • true—Task status is kept as IN_PROGRESS until an external event marks it as complete.
Optional.

Task configuration

This is the task configuration for an HTTP task.

  {
"name": "http",
"taskReferenceName": "http_ref",
"type": "HTTP",
"inputParameters": {
"uri": "https://orkes-api-tester.orkesconductor.com/api",
"method": "GET",
"accept": "application/json",
"contentType": "application/json",
"encode": true,
"hedgingConfig": {
"maxAttempts": "4"
},
"headers": {
"header-1": "${workflow.input.header-1}"
},
"body": {
"key": "value"
}
},
"asyncComplete": true
}

Task output

The HTTP task will return the following parameters.

ParameterDescription
responseA JSON object representing the response, if present.
headersAn object containing the metadata about the response.
statusCodeThe HTTP status code indicating success or failure of the request.
reasonPhraseThe reason phrase associated with the HTTP status code.
bodyThe response body containing the data returned by the API.

Adding an HTTP task in UI

An HTTP task can be configured manually through the UI or automatically populated using registered service definitions.

To add an HTTP task using registered services:

  1. In your workflow, select the (+) icon and add an HTTP task.
  2. Select Populate from remote services.
  3. In Service, select the registered HTTP service.
  4. In Service method, select the required endpoint.
  5. Select Populate.
  6. (Optional) In Hedging Config > Maximum attempts, enter a value for parallel hedged requests to reduce latency.

Adding HTTP task

This method automatically fills in the HTTP task parameters based on the selected service. It is recommended if you have already registered your HTTP services in Orkes Conductor.

Examples

Here are some examples for using the HTTP task.

Sending a POST request

Sample workflow for sending an HTTP POST request:

// task configuration

{
"name": "http_post_example",
"taskReferenceName": "post_example",
"inputParameters": {
"http_request": {
"uri": "https://jsonplaceholder.typicode.com/posts/",
"method": "POST",
"body": {
"title": "${get_example.output.response.body.title}",
"userId": "${get_example.output.response.body.userId}",
"action": "doSomething"
}
}
},
"type": "HTTP"
}

Orchestrating Long-Running APIs

Explore the full tutorial on orchestrating long-running APIs.

Sample Workflow using ‘Async Complete’ option

The asyncComplete option in the HTTP task configuration allows tasks to be marked as completed asynchronously, providing flexibility in workflow execution. Here's an example enabling ‘asyncComplete’:

{
"name": "async_complete_example",
"description": "Edit or extend this sample workflow. Set the workflow name to get started",
"version": 1,
"tasks": [
{
"name": "http_task_85tf2",
"taskReferenceName": "http_task_85tf2_ref",
"inputParameters": {
"http_request": {
"uri": "https://orkes-api-tester.orkesconductor.com/api",
"method": "GET",
"connectionTimeOut": 3000,
"readTimeOut": "3000",
"accept": "application/json",
"contentType": "application/json"
}
},
"type": "HTTP",
"asyncComplete": true
}
],
"schemaVersion": 2,
"ownerEmail": "john.doe@acme.com"
}

Now, let’s run this in the Developer Edition.

Run in Developer Edition

  1. Under Workflow Name, choose async_complete_example.
  2. Click Run Workflow.

Upon execution, the HTTP task remains “Scheduled” instead of completing immediately, allowing for asynchronous completion. The task can be completed using various methods:

Once the workflow runs, note the generated workflowId displayed near the workflow name on the execution page.

Workflow (execution) ID in Conductor

Use this workflowId along with the taskRefName to complete the task via the following API:

POST /api/tasks/{workflowId}/{taskRefName}/{status}

Employing these methods allows you to asynchronously complete your workflow, which is beneficial when pausing the workflow for external interventions.