Edit in GitHubLog an issue

Asynchronous Calls

The system executes web actions or REST APIs as synchronous (blocking) calls and gives them 60 seconds to complete their work. Actions that need more time can use asynchronous (async) calls, and use up to 180 minutes.

Since web actions and APIs are always executed synchronously, you need to separate work that needs more time (the async call) from work that can be done in under a minute using synchronous calls. There are two ways to do this:

Option 1: web action that calls the actual action async

First, we create an action. This one, worker, uses a setTimeout function to simulate long-running code.

Copied to your clipboard
// worker.js
function main(args) {
return new Promise(function(resolve, reject) {
setTimeout(function() {
var result = {
statusCode: 200,
body: {
payload: 'Hello from the long running job!'
}
};
resolve(result);
}, 100000);
});
}
exports.main = main;

Next we set the -t flag to change the default timeout. If we know that an action needs about 100,000 milliseconds to complete, we can set it to 120,000 milliseconds (2 minutes) to be sure it completes its work before timeout.

Copied to your clipboard
aio rt:action:create my-worker worker.js -t 120000

Then we build a web action that calls the worker action we created above. We can simplify this step by using the OpenWhisk Node module. Since it's part of I/O Runtime Node.js environment, we don't need to pack the module with our code.

Copied to your clipboard
//web-action.js
let openwhisk = require("openwhisk");
// This returns the activation ID of the action that it called
function main(args) {
let ow = openwhisk();
return ow.actions.invoke({
name: 'worker', // the name of the action to invoke
blocking: false, // this is the flag that instructs to execute the worker asynchronous
result: false,
params: args
});
}
exports.main = main;

Now we can create the web action:

Copied to your clipboard
aio rt:action:create test web-action.js --web true

Invoking this web action will deliver the ActivationId for the worker action, which can be used to retrieve the result.

In this sample invocation, the .json extension appended to the URI instructs the system to return the result as JSON:

Copied to your clipboard
curl https://adobeioruntime.net/api/v1/web/YOUR-NAMESPACE-HERE/default/test.json
{
"activationId": "0123456789"
}

Option 2: using triggers and rules

Another way to set up an asynchronous call is to create a trigger and a rule to call the action. This will work only for calls using a POST method; if you need a GET, use Option 1.

Here is the code, using the my-worker action from above:

Copied to your clipboard
// First, you create a trigger
aio rt:trigger:create my-worker-trigger
//Then, you create the rule
aio rt:rule:create async-rule my-worker-trigger my-worker

Now when the trigger my-worker-trigger is executed, it will in turn execute the my-worker action. Note the authentication header: it must match the authentication as used by the namespace where the actions, triggers, and rules were created.

Copied to your clipboard
curl https://adobeioruntime.net/api/v1/namespaces/_/triggers/my-worker-trigger -X POST -H "Authorization: Basic NAMESPACE AUTHORIZATION"

To find the URI and the authorization for a trigger or secured web action, add -v (verbose) to the command to get it:

Copied to your clipboard
aio rt:trigger:get my-worker-trigger -v

Retrieval of the action activationId (and not the trigger activationId) is trickier than in Option 1. Use the trigger activationId to retrieve the logs, which will contain the action activationId you can use to read the result.

Next steps

Learn about Triggers and Rules.

Return to Guides Index.

  • Privacy
  • Terms of Use
  • Do not sell or share my personal information
  • AdChoices
Copyright © 2025 Adobe. All rights reserved.