> This is part 1 of 7 of the full documentation (pages 1–100 of 633).
> The content is paginated: fetch every part to see all of it.
> Next part: https://docs.planetcrust.com/llms-full.txt/1
> Page index: https://docs.planetcrust.com/llms.txt
# About @Human
About @Human
### What are @Human Connections?
Connections is the API Ecosystem for @Human. There are three essential things you need to know:
{% stepper %}
{% step %}
### Open-Source Zapier Alternative
Similarly to Zapier, @Human Connections provides integrations with the API's of an ever-growing ecosystem of third-party technologies - though @Human is all open-source. Enter your API keys and off you go!
{% endstep %}
{% step %}
### Used in @Human Automations
@Human Automations is a TAQ (Trigger/Action/Query) engine in which you use your Connections. For example, you could create an automation where every time a Google Sheet row is added, this triggers the creation of a new record in your CRM.
{% endstep %}
{% step %}
### Easy to Build
API Connections are mostly straightforward for us to build. We just need your suggestions and preferences and we'll do it for free. Interested? Please join @Human Community (top of this page!) and let us know.
{% endstep %}
{% endstepper %}
# Configuring Connections
Put Asana to Work with @Human Automations and @Human Agents
The Asana Connection documents all Triggers, Actions and Query Operations available for creating automations via the Asana API.
{% embed url="" %}
#### What can you do with the Asana Connection?
* Connect to the Asana API in a few clicks
* Use the related Asana Operations (see below) in @Human Automations or @Human Agents
### Related Operations
#### Trigger Operations
**Task Created**
Triggers on: tasks/task\_created
Triggers when a new task is created in Asana.
**Task Updated**
Triggers on: tasks/task\_updated
Triggers when an existing task is updated in Asana.
**Project Created**
Triggers on: projects/project\_created
Triggers when a new project is created in Asana.
#### Action Operations
[Action: Create a Project](/asana/asana/action-create-a-project)
[Action: Update a Project](/asana/asana/action-update-a-project)
[Action: Create a Task](/asana/asana/action-create-a-task)
[Action: Update a Task](/asana/asana/action-update-a-task)
#### Query Operations
[Query: Get a Project](/asana/asana/query-get-a-project)
[Query: Get a Task](/asana/asana/query-get-a-task)
### Related Automations
Example link
### Obtaining Access Credentials
To obtain a **Personal Access Token (PAT)** for **Asana**, follow these steps:
#### **Prerequisites**
* An **Asana account** (free or paid).
* Admin permissions (if creating tokens for an organization).
#### **Steps**
1. **Log in** to your Asana account at [asana.com](https://asana.com).
2. **Click your profile icon** (top-right) → **Settings**.
3. Go to the **Apps** tab.
4. Under **Build new apps**, click **View developer console**.
5. Under **Personal access tokens,** Click **Create New Token**.
6. Enter a **name** (e.g., "API Integration") and set **expiration** (optional).
7. Click **Create Token**.
8. **Copy the token immediately** (it won’t be shown again).
9. **Done.** Use the token in API requests as a **Bearer Token** in the `Authorization` header.
### Configuring Webhooks
1. **Prepare a publicly accessible listener URL** (HTTPS) to receive event notifications.
2. **Implement the handshake response** to echo the `X-Hook-Secret` header back to Asana during the verification request.
3. **Register the webhook** by making an authenticated `POST` request to `https://app.asana.com/api/1.0/webhooks`.
4. **Use your Personal Access Token (PAT)** as a Bearer Token in the `Authorization` header.
5. **Specify the resource ID** (e.g., GID of a project or workspace) and the **target URL** in the JSON payload.
6. **Verify activation** by checking for a `201 Created` status from Asana once the handshake is successful.
### Code (Apache v2.0): Service Connectivity and Metadata
```
{
"handle": "asana-api-v1",
"status": "active",
"meta": {
"short": "Asana",
"description": "Connect to Asana's API to manage tasks, projects, and teams.",
"icon": "asana",
"tags": ["project-management", "task-management", "collaboration"]
},
"service": {
"baseURL": {
"value": "https://app.asana.com/api/1.0"
},
"protocol": "https",
"contentType": "application/json",
"headers": {
"Accept": {
"value": "application/json"
},
"Content-Type": {
"value": "application/json"
}
},
"auth": {
"method": "api_token",
"params": {
"apiToken": {
"token": {
"value": "{{apiToken}}",
"placeholders": [
{
"name": "apiToken",
"type": "String",
"description": "Asana Personal Access Token",
"required": true
}
]
},
"headerName": {
"value": "Authorization"
}
}
}
}
}
}
```
### Code (Apache v2.0): List of External Resources and Internal Mapping
```
[
{
"handle": "tasks",
"meta": {
"short": "Tasks",
"description": "Manage tasks in Asana, including creation, updates, and retrieval."
},
"endpoint": {
"value": "/tasks",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"id"
],
"meta": {
"description": "The unique identifier for the task."
}
},
{
"name": "name",
"type": "String",
"selector": [
"name"
],
"meta": {
"description": "The name of the task."
}
},
{
"name": "notes",
"type": "String",
"selector": [
"notes"
],
"meta": {
"description": "Detailed description or notes for the task."
}
},
{
"name": "completed",
"type": "Boolean",
"selector": [
"completed"
],
"meta": {
"description": "Indicates whether the task is completed."
}
},
{
"name": "due_on",
"type": "String",
"selector": [
"due_on"
],
"meta": {
"description": "The due date of the task in YYYY-MM-DD format."
}
}
],
"operations": {
"list": {
"method": "GET",
"path": {
"value": "",
"placeholders": []
},
"headers": {},
"queryParams": {},
"bodyTemplate": null
},
"read": {
"method": "GET",
"path": {
"value": "/{{id}}",
"placeholders": [
{
"name": "id",
"type": "String",
"description": "The task ID.",
"required": true
}
]
},
"headers": {},
"queryParams": {},
"bodyTemplate": null
},
"create": {
"method": "POST",
"path": {
"value": "",
"placeholders": []
},
"headers": {
"Content-Type": "application/json"
},
"queryParams": {},
"bodyTemplate": {
"value": "{\"data\": {\"name\": \"{{name}}\", \"notes\": \"{{notes}}\", \"due_on\": \"{{due_on}}\"}}",
"placeholders": [
{
"name": "name",
"type": "String",
"description": "The name of the task.",
"required": true
},
{
"name": "notes",
"type": "String",
"description": "Detailed description or notes for the task.",
"required": false
},
{
"name": "due_on",
"type": "String",
"description": "The due date of the task in YYYY-MM-DD format.",
"required": false
}
]
}
},
"update": {
"method": "PUT",
"path": {
"value": "/{{id}}",
"placeholders": [
{
"name": "id",
"type": "String",
"description": "The task ID.",
"required": true
}
]
},
"headers": {
"Content-Type": "application/json"
},
"queryParams": {},
"bodyTemplate": {
"value": "{\"data\": {\"name\": \"{{name}}\", \"notes\": \"{{notes}}\", \"completed\": {{completed}}, \"due_on\": \"{{due_on}}\"}}",
"placeholders": [
{
"name": "name",
"type": "String",
"description": "The name of the task.",
"required": false
},
{
"name": "notes",
"type": "String",
"description": "Detailed description or notes for the task.",
"required": false
},
{
"name": "completed",
"type": "Boolean",
"description": "Indicates whether the task is completed.",
"required": false
},
{
"name": "due_on",
"type": "String",
"description": "The due date of the task in YYYY-MM-DD format.",
"required": false
}
]
}
},
"delete": {
"method": "DELETE",
"path": {
"value": "/{{id}}",
"placeholders": [
{
"name": "id",
"type": "String",
"description": "The task ID.",
"required": true
}
]
},
"headers": {},
"queryParams": {},
"bodyTemplate": null
}
},
"webhooks": [
{
"event": "task_created",
"path": "/webhooks/asana/task_created",
"payload": [
{
"name": "task_id",
"type": "String",
"selector": [
"data",
"id"
],
"meta": {
"description": "The ID of the created task."
}
},
{
"name": "task_name",
"type": "String",
"selector": [
"data",
"name"
],
"meta": {
"description": "The name of the created task."
}
}
]
},
{
"event": "task_updated",
"path": "/webhooks/asana/task_updated",
"payload": [
{
"name": "task_id",
"type": "String",
"selector": [
"data",
"id"
],
"meta": {
"description": "The ID of the updated task."
}
},
{
"name": "task_name",
"type": "String",
"selector": [
"data",
"name"
],
"meta": {
"description": "The name of the updated task."
}
}
]
}
]
},
{
"handle": "projects",
"meta": {
"short": "Projects",
"description": "Manage projects in Asana, including creation, updates, and retrieval."
},
"endpoint": {
"value": "/projects",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"id"
],
"meta": {
"description": "The unique identifier for the project."
}
},
{
"name": "name",
"type": "String",
"selector": [
"name"
],
"meta": {
"description": "The name of the project."
}
},
{
"name": "notes",
"type": "String",
"selector": [
"notes"
],
"meta": {
"description": "Detailed description or notes for the project."
}
}
],
"operations": {
"list": {
"method": "GET",
"path": {
"value": "",
"placeholders": []
},
"headers": {},
"queryParams": {},
"bodyTemplate": null
},
"read": {
"method": "GET",
"path": {
"value": "/{{id}}",
"placeholders": [
{
"name": "id",
"type": "String",
"description": "The project ID.",
"required": true
}
]
},
"headers": {},
"queryParams": {},
"bodyTemplate": null
},
"create": {
"method": "POST",
"path": {
"value": "",
"placeholders": []
},
"headers": {
"Content-Type": "application/json"
},
"queryParams": {},
"bodyTemplate": {
"value": "{\"data\": {\"name\": \"{{name}}\", \"notes\": \"{{notes}}\"}}",
"placeholders": [
{
"name": "name",
"type": "String",
"description": "The name of the project.",
"required": true
},
{
"name": "notes",
"type": "String",
"description": "Detailed description or notes for the project.",
"required": false
}
]
}
},
"update": {
"method": "PUT",
"path": {
"value": "/{{id}}",
"placeholders": [
{
"name": "id",
"type": "String",
"description": "The project ID.",
"required": true
}
]
},
"headers": {
"Content-Type": "application/json"
},
"queryParams": {},
"bodyTemplate": {
"value": "{\"data\": {\"name\": \"{{name}}\", \"notes\": \"{{notes}}\"}}",
"placeholders": [
{
"name": "name",
"type": "String",
"description": "The name of the project.",
"required": false
},
{
"name": "notes",
"type": "String",
"description": "Detailed description or notes for the project.",
"required": false
}
]
}
},
"delete": {
"method": "DELETE",
"path": {
"value": "/{{id}}",
"placeholders": [
{
"name": "id",
"type": "String",
"description": "The project ID.",
"required": true
}
]
},
"headers": {},
"queryParams": {},
"bodyTemplate": null
}
},
"webhooks": [
{
"event": "project_created",
"path": "/webhooks/asana/project_created",
"payload": [
{
"name": "project_id",
"type": "String",
"selector": [
"data",
"id"
],
"meta": {
"description": "The ID of the created project."
}
},
{
"name": "project_name",
"type": "String",
"selector": [
"data",
"name"
],
"meta": {
"description": "The name of the created project."
}
}
]
}
]
},
{
"handle": "access-requests",
"meta": {
"short": "Access requests",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/access_requests",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the access request."
}
}
]
},
{
"handle": "allocations",
"meta": {
"short": "Allocations",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/allocations",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the allocation."
}
}
]
},
{
"handle": "attachments",
"meta": {
"short": "Attachments",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/attachments",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the attachment."
}
}
]
},
{
"handle": "audit-log-api",
"meta": {
"short": "Audit log API",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/audit_log_api",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the audit log api."
}
}
]
},
{
"handle": "batch-api",
"meta": {
"short": "Batch API",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/batch_api",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the batch api."
}
}
]
},
{
"handle": "budgets",
"meta": {
"short": "Budgets",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/budgets",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the budget."
}
}
]
},
{
"handle": "custom-field-settings",
"meta": {
"short": "Custom field settings",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/custom_field_settings",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the custom field setting."
}
}
]
},
{
"handle": "custom-fields",
"meta": {
"short": "Custom fields",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/custom_fields",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the custom field."
}
}
]
},
{
"handle": "custom-types",
"meta": {
"short": "Custom types",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/custom_types",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the custom type."
}
}
]
},
{
"handle": "exports",
"meta": {
"short": "Exports",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/exports",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the export."
}
}
]
},
{
"handle": "goal-relationships",
"meta": {
"short": "Goal relationships",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/goal_relationships",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the goal relationship."
}
}
]
},
{
"handle": "goals",
"meta": {
"short": "Goals",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/goals",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the goal."
}
}
]
},
{
"handle": "jobs",
"meta": {
"short": "Jobs",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/jobs",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the job."
}
}
]
},
{
"handle": "memberships",
"meta": {
"short": "Memberships",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/memberships",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the membership."
}
}
]
},
{
"handle": "organization-exports",
"meta": {
"short": "Organization exports",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/organization_exports",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the organization export."
}
}
]
},
{
"handle": "portfolio-memberships",
"meta": {
"short": "Portfolio memberships",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/portfolio_memberships",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the portfolio membership."
}
}
]
},
{
"handle": "portfolios",
"meta": {
"short": "Portfolios",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/portfolios",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the portfolio."
}
}
]
},
{
"handle": "project-briefs",
"meta": {
"short": "Project briefs",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/project_briefs",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the project brief."
}
}
]
},
{
"handle": "project-memberships",
"meta": {
"short": "Project memberships",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/project_memberships",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the project membership."
}
}
]
},
{
"handle": "project-portfolio-settings",
"meta": {
"short": "Project portfolio settings",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/project_portfolio_settings",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the project portfolio setting."
}
}
]
},
{
"handle": "project-statuses",
"meta": {
"short": "Project statuses",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/project_statuses",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the project statuse."
}
}
]
},
{
"handle": "project-templates",
"meta": {
"short": "Project templates",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/project_templates",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the project template."
}
}
]
},
{
"handle": "rates",
"meta": {
"short": "Rates",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/rates",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the rate."
}
}
]
},
{
"handle": "reactions",
"meta": {
"short": "Reactions",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/reactions",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the reaction."
}
}
]
},
{
"handle": "roles",
"meta": {
"short": "Roles",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/roles",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the role."
}
}
]
},
{
"handle": "rules",
"meta": {
"short": "Rules",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/rules",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the rule."
}
}
]
},
{
"handle": "sections",
"meta": {
"short": "Sections",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/sections",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the section."
}
}
]
},
{
"handle": "status-updates",
"meta": {
"short": "Status updates",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/status_updates",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the status update."
}
}
]
},
{
"handle": "stories",
"meta": {
"short": "Stories",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/stories",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the storie."
}
}
]
},
{
"handle": "tags",
"meta": {
"short": "Tags",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/tags",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the tag."
}
}
]
},
{
"handle": "task-templates",
"meta": {
"short": "Task templates",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/task_templates",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the task template."
}
}
]
},
{
"handle": "team-memberships",
"meta": {
"short": "Team memberships",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/team_memberships",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the team membership."
}
}
]
},
{
"handle": "teams",
"meta": {
"short": "Teams",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/teams",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the team."
}
}
]
},
{
"handle": "time-periods",
"meta": {
"short": "Time periods",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/time_periods",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the time period."
}
}
]
},
{
"handle": "time-tracking-entries",
"meta": {
"short": "Time tracking entries",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/time_tracking_entries",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the time tracking entrie."
}
}
]
},
{
"handle": "timesheet-approval-statuses",
"meta": {
"short": "Timesheet approval statuses",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/timesheet_approval_statuses",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the timesheet approval statuse."
}
}
]
},
{
"handle": "typeahead",
"meta": {
"short": "Typeahead",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/typeahead",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the typeahead."
}
}
]
},
{
"handle": "user-task-lists",
"meta": {
"short": "User task lists",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/user_task_lists",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the user task list."
}
}
]
},
{
"handle": "users",
"meta": {
"short": "Users",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/users",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the user."
}
}
]
},
{
"handle": "workspace-memberships",
"meta": {
"short": "Workspace memberships",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/workspace_memberships",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the workspace membership."
}
}
]
},
{
"handle": "workspaces",
"meta": {
"short": "Workspaces",
"description": "An access request object represents a user's request to an item, such as a project or portfolio, that they do not have access to. The request is sent to the owner of the item for approval."
},
"endpoint": {
"value": "/workspaces",
"placeholders": []
},
"fields": [
{
"name": "id",
"type": "String",
"selector": [
"gid"
],
"meta": {
"description": "The unique identifier for the workspace."
}
}
]
}
]
```
The Create a Project action enables users to automate the creation of an Asana Project.
{% embed url="" %}
#### Example User Story
As a project manager, I want to create a new project in Asana so that I can organize and track tasks effectively.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| name | String | Yes |
| workspace | String | Yes |
| notes | String | No |
| public | Boolean | No |
### Related Connections
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "create-project",
"state": "inDev",
"meta": {
"short": "Create Project",
"description": "Creates a new project in Asana."
},
"input": [
{
"name": "name",
"type": "String",
"required": true,
"meta": {
"description": "Name of the project."
}
},
{
"name": "workspace",
"type": "String",
"required": true,
"meta": {
"description": "Workspace ID where the project will be created."
}
},
{
"name": "notes",
"type": "String",
"required": false,
"meta": {
"description": "Notes for the project."
}
},
{
"name": "public",
"type": "Boolean",
"required": false,
"meta": {
"description": "Whether the project is public to the workspace."
}
}
],
"output": [
{
"name": "projectId",
"type": "String",
"selector": ["data", "gid"],
"meta": {
"description": "ID of the created project."
}
},
{
"name": "projectName",
"type": "String",
"selector": ["data", "name"],
"meta": {
"description": "Name of the created project."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/projects",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"data\":{\"name\":\"{{name}}\",\"workspace\":\"{{workspace}}\",\"notes\":\"{{notes}}\",\"public\":{{public}}}}",
"placeholders": [
{
"name": "accessToken",
"type": "String",
"description": "Asana API access token.",
"required": true
},
{
"name": "name",
"type": "String",
"description": "Name of the project.",
"required": true
},
{
"name": "workspace",
"type": "String",
"description": "Workspace ID where the project will be created.",
"required": true
},
{
"name": "notes",
"type": "String",
"description": "Notes for the project.",
"required": false
},
{
"name": "public",
"type": "Boolean",
"description": "Whether the project is public to the workspace.",
"required": false
}
]
}
}
}
]
}
```
The Update a Project action enables users to automate the update of an Asana Project.
{% embed url="" %}
#### Example User Story
As a project manager, I want to update project details in Asana so that I can keep project information current and relevant.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| projectId | String | Yes |
| name | String | No |
| notes | String | No |
| public | Boolean | No |
### Related Connections
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "update-project",
"state": "inDev",
"meta": {
"short": "Update Project",
"description": "Update an existing project in Asana with new details."
},
"input": [
{
"name": "projectId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the project to update."
}
},
{
"name": "name",
"type": "String",
"required": false,
"meta": {
"description": "The new name for the project."
}
},
{
"name": "notes",
"type": "String",
"required": false,
"meta": {
"description": "The new notes for the project."
}
},
{
"name": "public",
"type": "Boolean",
"required": false,
"meta": {
"description": "Whether the project is public to the organization."
}
}
],
"output": [
{
"name": "project",
"type": "Object",
"selector": ["data"],
"meta": {
"description": "The updated project details."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "PUT",
"path": "/projects/{{projectId}}",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"data\":{\"name\":\"{{name}}\",\"notes\":\"{{notes}}\",\"public\":{{public}}}}",
"placeholders": [
{
"name": "name",
"type": "String",
"description": "The new name for the project.",
"required": false
},
{
"name": "notes",
"type": "String",
"description": "The new notes for the project.",
"required": false
},
{
"name": "public",
"type": "Boolean",
"description": "Whether the project is public to the organization.",
"required": false
}
]
}
}
}
]
}
```
The Create a Task action enables users to automate the creation of a Task in an Asana Project.
{% embed url="" %}
#### Example User Story
As a project manager, I want to create a new task in Asana so that I can assign work to my team members.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| workspace | String | Yes |
| name | String | Yes |
| notes | String | No |
| projects | String | No |
| assignee | String | No |
| due\_on | String | No |
### Related Connections
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "create-task",
"state": "inDev",
"meta": {
"short": "Create Task",
"description": "Creates a new task in Asana."
},
"input": [
{
"name": "workspace",
"type": "String",
"required": true,
"meta": {
"description": "The workspace ID where the task will be created."
}
},
{
"name": "name",
"type": "String",
"required": true,
"meta": {
"description": "The name of the task."
}
},
{
"name": "notes",
"type": "String",
"required": false,
"meta": {
"description": "The description of the task."
}
},
{
"name": "projects",
"type": "String",
"required": false,
"meta": {
"description": "Comma-separated list of project IDs to add the task to."
}
},
{
"name": "assignee",
"type": "String",
"required": false,
"meta": {
"description": "The user ID to assign the task to."
}
},
{
"name": "due_on",
"type": "String",
"required": false,
"meta": {
"description": "The due date of the task in YYYY-MM-DD format."
}
}
],
"output": [
{
"name": "task_id",
"type": "String",
"selector": ["data", "gid"],
"meta": {
"description": "The ID of the created task."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/workspaces/{{workspace}}/tasks",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"data\":{\"name\":\"{{name}}\",\"notes\":\"{{notes}}\",\"projects\":[{{projects}}],\"assignee\":\"{{assignee}}\",\"due_on\":\"{{due_on}}\"}}",
"placeholders": [
{
"name": "name",
"type": "String",
"description": "The name of the task.",
"required": true
},
{
"name": "notes",
"type": "String",
"description": "The description of the task.",
"required": false
},
{
"name": "projects",
"type": "String",
"description": "Comma-separated list of project IDs to add the task to.",
"required": false
},
{
"name": "assignee",
"type": "String",
"description": "The user ID to assign the task to.",
"required": false
},
{
"name": "due_on",
"type": "String",
"description": "The due date of the task in YYYY-MM-DD format.",
"required": false
}
]
}
}
}
]
}
```
The Update a Task action enables users to automate the update of a Task in an Asana Project.
{% embed url="" %}
#### Example User Story
As a project manager, I want to update task details in Asana so that I can keep my team informed of changes.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| taskGID | String | Yes |
| name | String | No |
| notes | String | No |
| completed | Boolean | No |
| dueOn | String | No |
### Related Connections
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "update-task",
"state": "inDev",
"meta": {
"short": "Update Task",
"description": "Update an existing task in Asana."
},
"input": [
{
"name": "taskGID",
"type": "String",
"required": true,
"meta": {
"description": "The GID of the task to update."
}
},
{
"name": "name",
"type": "String",
"required": false,
"meta": {
"description": "The new name for the task."
}
},
{
"name": "notes",
"type": "String",
"required": false,
"meta": {
"description": "The new notes for the task."
}
},
{
"name": "completed",
"type": "Boolean",
"required": false,
"meta": {
"description": "Whether the task is completed."
}
},
{
"name": "dueOn",
"type": "String",
"required": false,
"meta": {
"description": "The due date of the task in YYYY-MM-DD format."
}
}
],
"output": [
{
"name": "task",
"type": "Object",
"selector": ["data"],
"meta": {
"description": "The updated task object."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "PUT",
"path": "/tasks/{{taskGID}}",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"data\": {\"name\": \"{{name}}\", \"notes\": \"{{notes}}\", \"completed\": {{completed}}, \"due_on\": \"{{dueOn}}\"}}",
"placeholders": [
{
"name": "name",
"type": "String",
"description": "The new name for the task.",
"required": false
},
{
"name": "notes",
"type": "String",
"description": "The new notes for the task.",
"required": false
},
{
"name": "completed",
"type": "Boolean",
"description": "Whether the task is completed.",
"required": false
},
{
"name": "dueOn",
"type": "String",
"description": "The due date of the task in YYYY-MM-DD format.",
"required": false
}
]
}
}
}
]
}
```
The Get a Project query enables users to fetch details of an Asana Project.
{% embed url="" %}
#### Example User Story
As a project manager, I want to retrieve the details of a specific project in Asana so that I can review its status and tasks.
#### Fields
| Field Name | Field Type | Required |
| ------------ | ---------- | -------- |
| project\_gid | String | Yes |
| opt\_fields | String | No |
### Related Connections
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "get-project",
"state": "inDev",
"meta": {
"short": "Get Project",
"description": "Retrieves details of a specific project in Asana."
},
"input": [
{
"name": "project_gid",
"type": "String",
"required": true,
"meta": {
"description": "The globally unique identifier (GID) of the project."
}
},
{
"name": "opt_fields",
"type": "String",
"required": false,
"meta": {
"description": "Comma-separated list of fields to include in the response."
}
}
],
"output": [
{
"name": "project",
"type": "Object",
"selector": ["data"],
"meta": {
"description": "The project details retrieved from Asana."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": {
"value": "/projects/{{project_gid}}",
"placeholders": [
{
"name": "project_gid",
"type": "String",
"description": "The globally unique identifier (GID) of the project.",
"required": true
}
]
},
"headers": {},
"queryParams": {
"opt_fields": {
"value": "{{opt_fields}}",
"placeholders": [
{
"name": "opt_fields",
"type": "String",
"description": "Comma-separated list of fields to include in the response.",
"required": false
}
]
}
}
}
}
]
}
```
The Get a Task query enables users to fetch details of an Asana Task.
{% embed url="" %}
#### Example User Story
As a project manager, I want to retrieve a specific task from Asana so that I can review its details and update its status.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| task\_id | String | Yes |
### Related Connections
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "get-task",
"state": "inDev",
"meta": {
"short": "Get Task",
"description": "Retrieve a specific task from Asana using its task ID."
},
"input": [
{
"name": "task_id",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the task to retrieve."
}
}
],
"output": [
{
"name": "task",
"type": "Object",
"selector": ["data"],
"meta": {
"description": "The retrieved task object."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/tasks/{{task_id}}",
"headers": {
"Content-Type": "application/json"
}
}
}
]
}
```
The Add Timesheet Clock Entries action records time entries for employee timesheets.
{% embed url="" %}
#### Example User Story
I want to add clock entries to an employee's timesheet in BambooHR so that I can accurately track their working hours.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| employeeId | Integer | Yes |
| date | String | Yes |
| start | String | Yes |
| end | String | Yes |
| note | String | No |
### Related Connections
[BambooHR](/bamboohr/bamboohr)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "add-timesheet-clock-entries",
"state": "inDev",
"meta": {
"short": "Add Timesheet Clock Entries",
"description": "Adds clock entries to a timesheet in BambooHR."
},
"input": [
{
"name": "employeeId",
"type": "Integer",
"required": true,
"meta": {
"description": "The ID of the employee."
}
},
{
"name": "date",
"type": "String",
"required": true,
"meta": {
"description": "The date of the clock entry in YYYY-MM-DD format."
}
},
{
"name": "start",
"type": "String",
"required": true,
"meta": {
"description": "The start time of the clock entry in HH:MM format."
}
},
{
"name": "end",
"type": "String",
"required": true,
"meta": {
"description": "The end time of the clock entry in HH:MM format."
}
},
{
"name": "note",
"type": "String",
"required": false,
"meta": {
"description": "An optional note for the clock entry."
}
}
],
"output": [
{
"name": "success",
"type": "Boolean",
"selector": ["success"],
"meta": {
"description": "Indicates if the clock entry was successfully added."
}
},
{
"name": "message",
"type": "String",
"selector": ["message"],
"meta": {
"description": "A message describing the result of the operation."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/api/gateway.php/v1/employees/{{employeeId}}/time_clock",
"headers": {
"Content-Type": "application/json",
"Accept": "application/json"
},
"bodyTemplate": {
"value": "{\"date\":\"{{date}}\",\"start\":\"{{start}}\",\"end\":\"{{end}}\",\"note\":\"{{note}}\"}",
"placeholders": [
{
"name": "employeeId",
"type": "Integer",
"description": "The ID of the employee.",
"required": true
},
{
"name": "date",
"type": "String",
"description": "The date of the clock entry in YYYY-MM-DD format.",
"required": true
},
{
"name": "start",
"type": "String",
"description": "The start time of the clock entry in HH:MM format.",
"required": true
},
{
"name": "end",
"type": "String",
"description": "The end time of the clock entry in HH:MM format.",
"required": true
},
{
"name": "note",
"type": "String",
"description": "An optional note for the clock entry.",
"required": false
}
]
}
}
}
]
}
```
The Update Employee action modifies an employee's existing record with new or updated information.
{% embed url="" %}
#### Example User Story
I want to update an employee's details in BambooHR so that I can keep employee records accurate and up-to-date.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| employeeId | String | Yes |
| firstName | String | No |
| lastName | String | No |
| jobTitle | String | No |
| workEmail | String | No |
| workPhone | String | No |
| department | String | No |
| location | String | No |
| status | String | No |
### Related Connections
[BambooHR](/bamboohr/bamboohr)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "update-employee",
"state": "inDev",
"meta": {
"short": "Update Employee",
"description": "Update an existing employee's details in BambooHR."
},
"input": [
{
"name": "employeeId",
"type": "String",
"required": true,
"meta": {
"description": "The unique identifier for the employee in BambooHR."
}
},
{
"name": "firstName",
"type": "String",
"required": false,
"meta": {
"description": "The first name of the employee."
}
},
{
"name": "lastName",
"type": "String",
"required": false,
"meta": {
"description": "The last name of the employee."
}
},
{
"name": "jobTitle",
"type": "String",
"required": false,
"meta": {
"description": "The job title of the employee."
}
},
{
"name": "workEmail",
"type": "String",
"required": false,
"meta": {
"description": "The work email address of the employee."
}
},
{
"name": "workPhone",
"type": "String",
"required": false,
"meta": {
"description": "The work phone number of the employee."
}
},
{
"name": "department",
"type": "String",
"required": false,
"meta": {
"description": "The department of the employee."
}
},
{
"name": "location",
"type": "String",
"required": false,
"meta": {
"description": "The location of the employee."
}
},
{
"name": "status",
"type": "String",
"required": false,
"meta": {
"description": "The employment status of the employee.",
"options": ["active", "inactive", "on leave"]
}
}
],
"output": [
{
"name": "success",
"type": "Boolean",
"selector": ["success"],
"meta": {
"description": "Indicates whether the update was successful."
}
},
{
"name": "employeeId",
"type": "String",
"selector": ["employeeId"],
"meta": {
"description": "The unique identifier for the updated employee."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/api/gateway.php/v1/employees/{{employeeId}}",
"headers": {
"Content-Type": "application/json",
"Accept": "application/json"
},
"bodyTemplate": {
"value": "{\n \"firstName\": \"{{firstName}}\",\n \"lastName\": \"{{lastName}}\",\n \"jobTitle\": \"{{jobTitle}}\",\n \"workEmail\": \"{{workEmail}}\",\n \"workPhone\": \"{{workPhone}}\",\n \"department\": \"{{department}}\",\n \"location\": \"{{location}}\",\n \"status\": \"{{status}}\"\n}",
"placeholders": [
{
"name": "employeeId",
"type": "String",
"description": "The unique identifier for the employee in BambooHR.",
"required": true
},
{
"name": "firstName",
"type": "String",
"description": "The first name of the employee.",
"required": false
},
{
"name": "lastName",
"type": "String",
"description": "The last name of the employee.",
"required": false
},
{
"name": "jobTitle",
"type": "String",
"description": "The job title of the employee.",
"required": false
},
{
"name": "workEmail",
"type": "String",
"description": "The work email address of the employee.",
"required": false
},
{
"name": "workPhone",
"type": "String",
"description": "The work phone number of the employee.",
"required": false
},
{
"name": "department",
"type": "String",
"description": "The department of the employee.",
"required": false
},
{
"name": "location",
"type": "String",
"description": "The location of the employee.",
"required": false
},
{
"name": "status",
"type": "String",
"description": "The employment status of the employee.",
"required": false,
"options": ["active", "inactive", "on leave"]
}
]
}
}
}
]
}
```
The Get Summary of Who's Out query retrieves a list of employees currently on leave or absent.
{% embed url="" %}
#### Example User Story
I want to retrieve a summary of who's out in my department this week so that I can plan resources accordingly.
#### Fields
| Field Name | Field Type | Required |
| ------------ | ---------- | -------- |
| departmentId | Integer | No |
| startDate | String | No |
| endDate | String | No |
### Related Connections
[BambooHR](/bamboohr/bamboohr)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "get-summary-of-whos-out",
"state": "inDev",
"meta": {
"short": "Get Summary of Who's Out",
"description": "Retrieves a summary of employees who are currently out of the office."
},
"input": [
{
"name": "departmentId",
"type": "Integer",
"required": false,
"meta": {
"description": "Filter by department ID."
}
},
{
"name": "startDate",
"type": "String",
"required": false,
"meta": {
"description": "Start date for the time-off summary (format: YYYY-MM-DD)."
}
},
{
"name": "endDate",
"type": "String",
"required": false,
"meta": {
"description": "End date for the time-off summary (format: YYYY-MM-DD)."
}
}
],
"output": [
{
"name": "summary",
"type": "String",
"selector": ["data", "summary"],
"meta": {
"description": "Summary of employees who are out."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/reports/whos_out",
"headers": {
"Accept": "application/json"
},
"queryParams": {
"departmentId": "{{departmentId}}",
"startDate": "{{startDate}}",
"endDate": "{{endDate}}"
}
}
}
]
}
```
The Like Post action lets you show appreciation for a post by adding your like to it.
{% embed url="" %}
#### Example User Story
I want to support a colleague’s creative project update, so I use the Like Post action in Bluesky to give it a quick thumbs-up.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| postID | String | Yes |
| userID | String | Yes |
### Related Connections
[Bluesky](/bluesky/bluesky)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "like-post",
"state": "inDev",
"meta": {
"short": "Like Post",
"description": "Likes a post on Bluesky."
},
"input": [
{
"name": "postID",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the post to like."
}
},
{
"name": "userID",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the user liking the post."
}
}
],
"output": [
{
"name": "success",
"type": "Boolean",
"selector": ["success"],
"meta": {
"description": "Indicates whether the post was liked successfully."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/xrpc/app.bsky.feed.like",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"repo\": \"{{userID}}\", \"collection\": \"app.bsky.feed.like\", \"record\": {\"subject\": {\"uri\": \"at://{{postID}}\"}, \"createdAt\": \"{{now}}\"}}",
"placeholders": [
{
"name": "userID",
"type": "String",
"description": "The ID of the user liking the post.",
"required": true
},
{
"name": "postID",
"type": "String",
"description": "The ID of the post to like.",
"required": true
},
{
"name": "now",
"type": "String",
"description": "Current timestamp in ISO format.",
"required": true,
"default": "{{now}}"
}
]
}
}
}
]
}
```
The Repost Post action lets you share someone else’s post with your own followers, similar to a retweet.
{% embed url="" %}
#### Example User Story
I want to share an insightful industry article with my network, so I use the Repost Post action in Bluesky to quickly amplify it to my followers.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| postId | String | Yes |
### Related Connections
[Bluesky](/bluesky/bluesky)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "repost-post",
"state": "inDev",
"meta": {
"short": "Repost Post",
"description": "Repost a post on Bluesky."
},
"input": [
{
"name": "postId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the post to repost."
}
}
],
"output": [
{
"name": "success",
"type": "Boolean",
"selector": ["success"],
"meta": {
"description": "Indicates whether the repost was successful."
}
},
{
"name": "repostId",
"type": "String",
"selector": ["data", "repostId"],
"meta": {
"description": "The ID of the reposted post."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/xrpc/com/atproto/repo/createRecord",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"repo\": \"{{repo}}\", \"collection\": \"app.bsky.feed.post\", \"record\": {\"text\": \"{{text}}\", \"createdAt\": \"{{createdAt}}\"}}",
"placeholders": [
{
"name": "repo",
"type": "String",
"description": "The repository handle.",
"required": true
},
{
"name": "text",
"type": "String",
"description": "The text content of the post.",
"required": true
},
{
"name": "createdAt",
"type": "String",
"description": "The creation timestamp of the post.",
"required": true
}
]
}
}
}
]
}
```
The Create Post action lets you compose and publish a new post with text, images, or links.
{% embed url="" %}
#### Example User Story
I want to announce our team’s latest milestone, so I use the Create Post action in Bluesky to share the news with our followers.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| text | String | Yes |
| replyTo | String | No |
| embed | Object | No |
### Related Connections
[Bluesky](/bluesky/bluesky)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "create-post",
"state": "inDev",
"meta": {
"short": "Create Post",
"description": "Create a new post on Bluesky."
},
"input": [
{
"name": "text",
"type": "String",
"required": true,
"meta": {
"description": "The text content of the post."
}
},
{
"name": "replyTo",
"type": "String",
"required": false,
"meta": {
"description": "The URI of the post being replied to."
}
},
{
"name": "embed",
"type": "Object",
"required": false,
"meta": {
"description": "Embedded content, such as images or external links."
}
}
],
"output": [
{
"name": "uri",
"type": "String",
"selector": ["uri"],
"meta": {
"description": "The URI of the created post."
}
},
{
"name": "cid",
"type": "String",
"selector": ["cid"],
"meta": {
"description": "The CID (Content Identifier) of the created post."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/xrpc/com.atproto.repo.createRecord",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"collection\":\"app.bsky.feed.post\",\"repo\":\"{{did}}\",\"record\":{\"text\":\"{{text}}\",\"reply\":{{if replyTo}}\"{\"root\":{\"uri\":\"{{replyTo}}\"}}\"{{else}}null{{end}},\"embed\":{{if embed}}{{embed}}{{else}}null{{end}},\"createdAt\":\"{{now}}\"}}",
"placeholders": [
{
"name": "authToken",
"type": "String",
"description": "Authentication token for Bluesky API.",
"required": true
},
{
"name": "did",
"type": "String",
"description": "Decentralized Identifier (DID) of the user.",
"required": true
},
{
"name": "text",
"type": "String",
"description": "The text content of the post.",
"required": true
},
{
"name": "replyTo",
"type": "String",
"description": "The URI of the post being replied to.",
"required": false
},
{
"name": "embed",
"type": "Object",
"description": "Embedded content, such as images or external links.",
"required": false
},
{
"name": "now",
"type": "String",
"description": "Current timestamp in ISO 8601 format.",
"required": true,
"default": "{{now}}"
}
]
}
}
}
]
}
```
The Find Thread query lets you search for and locate a specific conversation or post thread by keyword, user, or other criteria.
{% embed url="" %}
#### Example User Story
I want to revisit the discussion about our new product features, so I use the Find Thread action in Bluesky to quickly locate the relevant conversation.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| threadID | String | Yes |
### Related Connections
[Bluesky](/bluesky/bluesky)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "find-thread",
"state": "inDev",
"meta": {
"short": "Find Thread",
"description": "Retrieve a specific thread from Bluesky based on its identifier."
},
"input": [
{
"name": "threadID",
"type": "String",
"required": true,
"meta": {
"description": "The unique identifier of the thread to retrieve."
}
}
],
"output": [
{
"name": "thread",
"type": "Object",
"selector": ["thread"],
"meta": {
"description": "The retrieved thread object."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/xrpc/com/atproto/repo/getRecord",
"queryParams": {
"repo": "{{threadID.split('.')[0]}}",
"collection": "app.bsky.feed.post",
"rkey": "{{threadID.split('.')[1]}}"
}
}
}
]
}
```
Put Canva to Work with @Human Automations and @Human Agents
The Canva Connection documents all Triggers, Actions and Query Operations available for creating automations via the Canva API.
{% embed url="" %}
#### What can you do with the Canva Connection?
* Connect to the Canva API in a few clicks
* Use the related Canva Operations (see below) in @Human Automations or @Human Agents
### Related Operations
#### Trigger Operations
**Asset Upload Completed**
Triggers on: asset/asset\_upload\_completed
Triggered when an asset upload job has finished.
**Autofill Job Completed**
Triggers on: autofill/autofill\_job\_completed
Triggered when an autofill job has finished.
**Comment Created**
Triggers on: comment/comment\_created
Triggered when a new comment is created on a design.
**Design Created**
Triggers on: design/design\_created
Triggered when a new design is created.
**Design Updated**
Triggers on: design/design\_updated
Triggered when an existing design is updated.
**Design Deleted**
Triggers on: design/design\_deleted
Triggered when a design is deleted.
**Design Published**
Triggers on: design/design\_published
Triggered when a design is published.
**Import Job Completed**
Triggers on: design\_import/import\_job\_completed
Triggered when a design import job has finished.
**Export Job Completed**
Triggers on: export/export\_job\_completed
Triggered when an export job has finished.
**Folder Created**
Triggers on: folder/folder\_created
Triggered when a new folder is created.
**Folder Updated**
Triggers on: folder/folder\_updated
Triggered when a folder's details are updated.
**Folder Deleted**
Triggers on: folder/folder\_deleted
Triggered when a folder is deleted.
**Resize Job Completed**
Triggers on: resize/resize\_job\_completed
Triggered when a resize job has finished.
#### Action Operations
[Action: Upload Asset](/canva/canva/action-upload-asset)
[Action: Autofill Design From Brand Template](/canva/canva/action-autofill-design-from-brand-template)
[Action: Import Design](/canva/canva/action-import-design)
[Action: API Request](/canva/canva/action-api-request)
#### Query Operations
Example link
### Related Automations
Example link
### Obtaining Access Credentials
To obtain a **Personal Access Token (PAT)** for **Canva** (system-to-system access), follow these steps:
#### **Prerequisites**
* A **Canva Pro/Enterprise** account (PATs are not available for free accounts).
* Admin access if generating tokens for a team.
#### **Steps**
1. **Log in** to your Canva account at .
2. **Click your profile icon** (top-right) → **Account Settings**.
3. Navigate to **Apps & Integrations** → **API & Developers**.
4. Under **Personal Access Tokens**, click **Generate Token**.
5. Enter a **Token Name** (e.g., "API Integration").
6. Select **Scopes** (permissions) for the token:
* Common scopes: `design:read`, `design:write`, `user:read`.
7. Click **Generate Token** → Copy the token immediately (it won’t be shown again).
### Configuring Webhooks
1. **Log in** to the **Canva Developer Portal** at .
2. Select your integration from the **Your integrations** list.
3. Click on **Configuration** in the left-hand navigation menu.
4. Locate the **Webhook URL** section and enter your server's **Publicly accessible URL**.
5. Click **Save changes**.
6. Navigate to the **Scopes** page in the left sidebar.
7. Enable the **scopes** corresponding to the events you wish to receive (e.g., `collaboration:event`).
8. Click **Save changes**.
### Code (Apache v2.0): Service Connectivity and Metadata
```
{
"handle": "canva",
"status": "active",
"meta": {
"short": "Canva",
"description": "Connect to Canva's design platform to manage designs, templates, and assets.",
"icon": "canva",
"tags": ["design", "graphics", "templates", "creative"]
},
"service": {
"baseURL": {
"value": "https://api.canva.com/v1"
},
"protocol": "https",
"contentType": "application/json",
"headers": {
"Accept": {
"value": "application/json"
},
"Content-Type": {
"value": "application/json"
}
},
"auth": {
"method": "system_to_system",
"params": {}
}
}
}
```
### Code (Apache v2.0): List of External Resources and Internal Mapping
```
[
{
"handle": "app",
"meta": {
"short": "App",
"description": "Manage app resources via Canva Connect API."
},
"endpoint": {
"value": ""
},
"webhooks": [],
"operations": {
"get": {
"method": "GET",
"path": {
"value": "/v1/apps/{appId}/jwks"
},
"headers": {},
"meta": {
"description": "Returns the Json Web Key Set (public keys) of an app. These keys are used to"
}
}
}
},
{
"handle": "asset",
"meta": {
"short": "Asset",
"description": "Manage asset resources via Canva Connect API."
},
"endpoint": {
"value": ""
},
"webhooks": [
{
"event": "asset_upload_completed",
"path": "/webhooks/canva/asset_upload_completed",
"payload": [
{ "name": "asset_id", "type": "String", "selector": ["asset", "id"], "meta": { "description": "ID of the uploaded asset." } },
{ "name": "name", "type": "String", "selector": ["asset", "name"], "meta": { "description": "Name of the asset." } },
{ "name": "status", "type": "String", "selector": ["job", "status"], "meta": { "description": "Upload job status." } }
]
}
],
"operations": {
"delete": {
"method": "DELETE",
"path": {
"value": "/v1/assets/{assetId}"
},
"headers": {},
"meta": {
"description": "You can delete an asset by specifying its `assetId`. This operation mirrors the behavior"
}
},
"get": {
"method": "GET",
"path": {
"value": "/v1/assets/{assetId}"
},
"headers": {},
"meta": {
"description": "You can retrieve the metadata of an asset by specifying its `assetId`."
}
},
"patch": {
"method": "PATCH",
"path": {
"value": "/v1/assets/{assetId}"
},
"headers": {},
"meta": {
"description": "You can update the name and tags of an asset by specifying its `assetId`. Updating the tags"
}
},
"post": {
"method": "POST",
"path": {
"value": "/v1/asset-uploads"
},
"headers": {},
"meta": {
"description": "Starts a new [asynchronous job](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints) to upload an asset to the user's content library. Supported file types for assets are listed in the [Assets API overview](https://www.canva.dev/docs/connect/api-reference/assets/)."
}
},
"get_jobId": {
"method": "GET",
"path": {
"value": "/v1/url-asset-uploads/{jobId}"
},
"headers": {},
"meta": {
"description": ""
}
},
"post_url-asset-uploads": {
"method": "POST",
"path": {
"value": "/v1/url-asset-uploads"
},
"headers": {},
"meta": {
"description": ""
}
}
}
},
{
"handle": "autofill",
"meta": {
"short": "Autofill",
"description": "Manage autofill resources via Canva Connect API."
},
"endpoint": {
"value": ""
},
"webhooks": [
{
"event": "autofill_job_completed",
"path": "/webhooks/canva/autofill_job_completed",
"payload": [
{ "name": "job_id", "type": "String", "selector": ["job", "id"], "meta": { "description": "ID of the autofill job." } },
{ "name": "status", "type": "String", "selector": ["job", "status"], "meta": { "description": "Status of the autofill job." } },
{ "name": "design_id", "type": "String", "selector": ["job", "design_id"], "meta": { "description": "ID of the resulting design." } }
]
}
],
"operations": {
"post": {
"method": "POST",
"path": {
"value": "/v1/autofills"
},
"headers": {},
"meta": {
"description": "WARNING: Brand templates were migrated to use a new ID format in September 2025. If your integration stores brand template IDs, you'll need to migrate to use the new IDs. Old brand template IDs will continue to be accepted for 6 months to give you time to migrate to the new IDs."
}
},
"get": {
"method": "GET",
"path": {
"value": "/v1/autofills/{jobId}"
},
"headers": {},
"meta": {
"description": "AVAILABILITY: To use this API, your integration must act on behalf of a user that's a member of a [Canva Enterprise](https://www.canva.com/enterprise/) organization."
}
}
}
},
{
"handle": "brand_template",
"meta": {
"short": "Brand Template",
"description": "Manage brand template resources via Canva Connect API."
},
"endpoint": {
"value": ""
},
"webhooks": [],
"operations": {
"get": {
"method": "GET",
"path": {
"value": "/v1/brand-templates"
},
"headers": {},
"meta": {
"description": "WARNING: Brand templates were migrated to use a new ID format in September 2025. If your integration stores brand template IDs, you'll need to migrate to use the new IDs. Old brand template IDs will continue to be accepted for 6 months to give you time to migrate to the new IDs."
}
},
"get_brandTemplateId": {
"method": "GET",
"path": {
"value": "/v1/brand-templates/{brandTemplateId}"
},
"headers": {},
"meta": {
"description": "WARNING: Brand templates were migrated to use a new ID format in September 2025. If your integration stores brand template IDs, you'll need to migrate to use the new IDs. Old brand template IDs will continue to be accepted for 6 months to give you time to migrate to the new IDs."
}
},
"get_dataset": {
"method": "GET",
"path": {
"value": "/v1/brand-templates/{brandTemplateId}/dataset"
},
"headers": {},
"meta": {
"description": "WARNING: Brand templates were migrated to use a new ID format in September 2025. If your integration stores brand template IDs, you'll need to migrate to use the new IDs. Old brand template IDs will continue to be accepted for 6 months to give you time to migrate to the new IDs."
}
}
}
},
{
"handle": "comment",
"meta": {
"short": "Comment",
"description": "Manage comment resources via Canva Connect API."
},
"endpoint": {
"value": ""
},
"webhooks": [
{
"event": "comment_created",
"path": "/webhooks/canva/comment_created",
"payload": [
{ "name": "comment_id", "type": "String", "selector": ["comment", "id"], "meta": { "description": "ID of the comment." } },
{ "name": "design_id", "type": "String", "selector": ["comment", "design_id"], "meta": { "description": "ID of the design the comment belongs to." } },
{ "name": "message", "type": "String", "selector": ["comment", "message"], "meta": { "description": "Text content of the comment." } }
]
}
],
"operations": {
"post": {
"method": "POST",
"path": {
"value": "/v1/comments"
},
"headers": {},
"meta": {
"description": ""
}
},
"post_replies": {
"method": "POST",
"path": {
"value": "/v1/designs/{designId}/comments/{threadId}/replies"
},
"headers": {},
"meta": {
"description": ""
}
},
"get": {
"method": "GET",
"path": {
"value": "/v1/designs/{designId}/comments/{threadId}/replies"
},
"headers": {},
"meta": {
"description": ""
}
},
"get_threadId": {
"method": "GET",
"path": {
"value": "/v1/designs/{designId}/comments/{threadId}"
},
"headers": {},
"meta": {
"description": ""
}
},
"get_replyId": {
"method": "GET",
"path": {
"value": "/v1/designs/{designId}/comments/{threadId}/replies/{replyId}"
},
"headers": {},
"meta": {
"description": ""
}
},
"post_comments": {
"method": "POST",
"path": {
"value": "/v1/designs/{designId}/comments"
},
"headers": {},
"meta": {
"description": ""
}
}
}
},
{
"handle": "connect",
"meta": {
"short": "Connect",
"description": "Manage connect resources via Canva Connect API."
},
"endpoint": {
"value": ""
},
"webhooks": [],
"operations": {
"get": {
"method": "GET",
"path": {
"value": "/v1/connect/keys"
},
"headers": {},
"meta": {
"description": ""
}
}
}
},
{
"handle": "design",
"meta": {
"short": "Design",
"description": "Manage design resources via Canva Connect API."
},
"endpoint": {
"value": ""
},
"webhooks": [
{
"event": "design_created",
"path": "/webhooks/canva/design_created",
"payload": [
{ "name": "design_id", "type": "String", "selector": ["design", "id"], "meta": { "description": "ID of the created design." } },
{ "name": "title", "type": "String", "selector": ["design", "title"], "meta": { "description": "Title of the design." } }
]
},
{
"event": "design_updated",
"path": "/webhooks/canva/design_updated",
"payload": [
{ "name": "design_id", "type": "String", "selector": ["design", "id"], "meta": { "description": "ID of the updated design." } },
{ "name": "title", "type": "String", "selector": ["design", "title"], "meta": { "description": "Title of the design." } }
]
},
{
"event": "design_deleted",
"path": "/webhooks/canva/design_deleted",
"payload": [
{ "name": "design_id", "type": "String", "selector": ["design", "id"], "meta": { "description": "ID of the deleted design." } }
]
},
{
"event": "design_published",
"path": "/webhooks/canva/design_published",
"payload": [
{ "name": "design_id", "type": "String", "selector": ["design", "id"], "meta": { "description": "ID of the published design." } },
{ "name": "url", "type": "String", "selector": ["design", "url"], "meta": { "description": "URL of the published design." } }
]
}
],
"operations": {
"get": {
"method": "GET",
"path": {
"value": "/v1/designs"
},
"headers": {},
"meta": {
"description": "Lists metadata for all the designs in a Canva user's"
}
},
"post": {
"method": "POST",
"path": {
"value": "/v1/designs"
},
"headers": {},
"meta": {
"description": "Creates a new Canva design. To create a new design, you can either:"
}
},
"get_designId": {
"method": "GET",
"path": {
"value": "/v1/designs/{designId}"
},
"headers": {},
"meta": {
"description": "Gets the metadata for a design. This includes owner information, URLs for editing and viewing, and thumbnail information."
}
},
"get_pages": {
"method": "GET",
"path": {
"value": "/v1/designs/{designId}/pages"
},
"headers": {},
"meta": {
"description": ""
}
},
"get_export-formats": {
"method": "GET",
"path": {
"value": "/v1/designs/{designId}/export-formats"
},
"headers": {},
"meta": {
"description": "Lists the available file formats for [exporting a design](https://www.canva.dev/docs/connect/api-reference/exports/create-design-export-job/)."
}
}
}
},
{
"handle": "design_import",
"meta": {
"short": "Design Import",
"description": "Manage design import resources via Canva Connect API."
},
"endpoint": {
"value": ""
},
"webhooks": [
{
"event": "import_job_completed",
"path": "/webhooks/canva/import_job_completed",
"payload": [
{ "name": "job_id", "type": "String", "selector": ["job", "id"], "meta": { "description": "ID of the import job." } },
{ "name": "status", "type": "String", "selector": ["job", "status"], "meta": { "description": "Status of the job." } },
{ "name": "design_id", "type": "String", "selector": ["job", "design_id"], "meta": { "description": "ID of the resulting design." } }
]
}
],
"operations": {
"post": {
"method": "POST",
"path": {
"value": "/v1/imports"
},
"headers": {},
"meta": {
"description": "Starts a new [asynchronous job](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints) to import an external file as a new design in Canva."
}
},
"get": {
"method": "GET",
"path": {
"value": "/v1/imports/{jobId}"
},
"headers": {},
"meta": {
"description": "Gets the result of a design import job created using the [Create design import job API](https://www.canva.dev/docs/connect/api-reference/design-imports/create-design-import-job/)."
}
},
"post_url-imports": {
"method": "POST",
"path": {
"value": "/v1/url-imports"
},
"headers": {},
"meta": {
"description": "Starts a new [asynchronous job](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints) to import an external file from a URL as a new design in Canva."
}
},
"get_jobId": {
"method": "GET",
"path": {
"value": "/v1/url-imports/{jobId}"
},
"headers": {},
"meta": {
"description": "Gets the result of a URL import job created using the [Create URL import job API](https://www.canva.dev/docs/connect/api-reference/design-imports/create-url-import-job/)."
}
}
}
},
{
"handle": "export",
"meta": {
"short": "Export",
"description": "Manage export resources via Canva Connect API."
},
"endpoint": {
"value": ""
},
"webhooks": [
{
"event": "export_job_completed",
"path": "/webhooks/canva/export_job_completed",
"payload": [
{ "name": "job_id", "type": "String", "selector": ["job", "id"], "meta": { "description": "ID of the export job." } },
{ "name": "status", "type": "String", "selector": ["job", "status"], "meta": { "description": "Status of the job." } },
{ "name": "url", "type": "String", "selector": ["job", "export_url"], "meta": { "description": "URL to download the exported file." } }
]
}
],
"operations": {
"post": {
"method": "POST",
"path": {
"value": "/v1/exports"
},
"headers": {},
"meta": {
"description": "Starts a new [asynchronous job](https://www.canva.dev/docs/connect/api-requests-responses/#asynchronous-job-endpoints) to export a file from Canva. Once the exported file is generated, you can download"
}
},
"get": {
"method": "GET",
"path": {
"value": "/v1/exports/{exportId}"
},
"headers": {},
"meta": {
"description": "Gets the result of a design export job that was created using the [Create design export job API](https://www.canva.dev/docs/connect/api-reference/exports/create-design-export-job/)."
}
}
}
},
{
"handle": "folder",
"meta": {
"short": "Folder",
"description": "Manage folder resources via Canva Connect API."
},
"endpoint": {
"value": ""
},
"webhooks": [
{
"event": "folder_created",
"path": "/webhooks/canva/folder_created",
"payload": [
{ "name": "folder_id", "type": "String", "selector": ["folder", "id"], "meta": { "description": "ID of the created folder." } },
{ "name": "name", "type": "String", "selector": ["folder", "name"], "meta": { "description": "Name of the folder." } }
]
},
{
"event": "folder_updated",
"path": "/webhooks/canva/folder_updated",
"payload": [
{ "name": "folder_id", "type": "String", "selector": ["folder", "id"], "meta": { "description": "ID of the updated folder." } },
{ "name": "name", "type": "String", "selector": ["folder", "name"], "meta": { "description": "Name of the folder." } }
]
},
{
"event": "folder_deleted",
"path": "/webhooks/canva/folder_deleted",
"payload": [
{ "name": "folder_id", "type": "String", "selector": ["folder", "id"], "meta": { "description": "ID of the deleted folder." } }
]
}
],
"operations": {
"delete": {
"method": "DELETE",
"path": {
"value": "/v1/folders/{folderId}"
},
"headers": {},
"meta": {
"description": "Deletes a folder with the specified `folderID`."
}
},
"get": {
"method": "GET",
"path": {
"value": "/v1/folders/{folderId}"
},
"headers": {},
"meta": {
"description": "Gets the name and other details of a folder using a folder's `folderID`."
}
},
"patch": {
"method": "PATCH",
"path": {
"value": "/v1/folders/{folderId}"
},
"headers": {},
"meta": {
"description": "Updates a folder's details using its `folderID`."
}
},
"get_items": {
"method": "GET",
"path": {
"value": "/v1/folders/{folderId}/items"
},
"headers": {},
"meta": {
"description": "Lists the items in a folder, including each item's `type`."
}
},
"post": {
"method": "POST",
"path": {
"value": "/v1/folders/move"
},
"headers": {},
"meta": {
"description": "Moves an item to another folder. You must specify the folder ID of the destination folder, as well as the ID of the item you want to move."
}
},
"post_folders": {
"method": "POST",
"path": {
"value": "/v1/folders"
},
"headers": {},
"meta": {
"description": "Creates a folder in one of the following locations:"
}
}
}
},
{
"handle": "oauth",
"meta": {
"short": "Oauth",
"description": "Manage oauth resources via Canva Connect API."
},
"endpoint": {
"value": ""
},
"webhooks": [],
"operations": {
"post": {
"method": "POST",
"path": {
"value": "/v1/oauth/token"
},
"headers": {},
"meta": {
"description": "This endpoint implements the OAuth 2.0 `token` endpoint, as part of the Authorization Code flow with Proof Key for Code Exchange (PKCE). For more information, see [Authentication](https://www.canva.dev/docs/connect/authentication/)."
}
},
"post_introspect": {
"method": "POST",
"path": {
"value": "/v1/oauth/introspect"
},
"headers": {},
"meta": {
"description": "Introspect an access token to see whether it is valid and active. You can also verify some token properties, such as its claims, scopes, and validity times."
}
},
"post_revoke": {
"method": "POST",
"path": {
"value": "/v1/oauth/revoke"
},
"headers": {},
"meta": {
"description": "Revoke an access token or a refresh token."
}
}
}
},
{
"handle": "oidc",
"meta": {
"short": "Oidc",
"description": "Manage oidc resources via Canva Connect API."
},
"endpoint": {
"value": ""
},
"webhooks": [],
"operations": {
"get": {
"method": "GET",
"path": {
"value": "/v1/oidc/jwks"
},
"headers": {},
"meta": {
"description": "Gets the JSON Web Key Set (public keys) for OIDC. These keys are used to verify JWTs in OpenID Connect flows."
}
},
"get_userinfo": {
"method": "GET",
"path": {
"value": "/v1/oidc/userinfo"
},
"headers": {},
"meta": {
"description": "Fetches the current UserInfo claims for the authorized user. This is the same fields"
}
}
}
},
{
"handle": "resize",
"meta": {
"short": "Resize",
"description": "Manage resize resources via Canva Connect API."
},
"endpoint": {
"value": ""
},
"webhooks": [
{
"event": "resize_job_completed",
"path": "/webhooks/canva/resize_job_completed",
"payload": [
{ "name": "job_id", "type": "String", "selector": ["job", "id"], "meta": { "description": "ID of the resize job." } },
{ "name": "status", "type": "String", "selector": ["job", "status"], "meta": { "description": "Status of the job." } },
{ "name": "design_id", "type": "String", "selector": ["job", "design_id"], "meta": { "description": "ID of the resulting design." } }
]
}
],
"operations": {
"post": {
"method": "POST",
"path": {
"value": "/v1/resizes"
},
"headers": {},
"meta": {
"description": "AVAILABILITY: To use this API, your integration must act on behalf of a user that's on a Canva plan with premium features (such as Canva Pro)."
}
},
"get": {
"method": "GET",
"path": {
"value": "/v1/resizes/{jobId}"
},
"headers": {},
"meta": {
"description": "AVAILABILITY: To use this API, your integration must act on behalf of a user that's on a Canva plan with premium features (such as Canva Pro)."
}
}
}
},
{
"handle": "user",
"meta": {
"short": "User",
"description": "Manage user resources via Canva Connect API."
},
"endpoint": {
"value": ""
},
"webhooks": [],
"operations": {
"get": {
"method": "GET",
"path": {
"value": "/v1/users/me"
},
"headers": {},
"meta": {
"description": "Returns the User ID and Team ID of the user"
}
},
"get_capabilities": {
"method": "GET",
"path": {
"value": "/v1/users/me/capabilities"
},
"headers": {},
"meta": {
"description": "Lists the API capabilities for the user account associated with the provided access token. For more information, see [Capabilities](https://www.canva.dev/docs/connect/capabilities/)."
}
},
"get_profile": {
"method": "GET",
"path": {
"value": "/v1/users/me/profile"
},
"headers": {},
"meta": {
"description": "Currently, this returns the display name of the user account associated with the provided access token. More user information is expected to be included in the future."
}
}
}
}
]
```
The Upload Asset action in Canva allows you to add your own images, videos, or files to use in your designs.
{% embed url="" %}
#### Example User Story
I want to quickly add my company logo to a social media post, so I use the Upload Asset action in Canva to import the logo file and place it seamlessly into my design.
#### Fields
| Field Name | Field Type | Required |
| ----------- | ---------- | -------- |
| file | File | Yes |
| folderId | String | No |
| accessToken | String | Yes |
### Related Connections
[Canva](/canva/canva)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "upload-asset",
"state": "inDev",
"meta": {
"short": "Upload Asset",
"description": "Uploads an asset (image, video, etc.) to Canva."
},
"input": [
{
"name": "file",
"type": "File",
"required": true,
"meta": {
"description": "The file to upload."
}
},
{
"name": "folderId",
"type": "String",
"required": false,
"meta": {
"description": "The ID of the folder where the asset will be uploaded."
}
}
],
"output": [
{
"name": "assetId",
"type": "String",
"selector": ["id"],
"meta": {
"description": "The ID of the uploaded asset."
}
},
{
"name": "assetUrl",
"type": "String",
"selector": ["url"],
"meta": {
"description": "The URL of the uploaded asset."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v1/uploads",
"headers": {
"Content-Type": "multipart/form-data"
},
"bodyTemplate": {
"value": "--boundary\nContent-Disposition: form-data; name=\"file\"; filename=\"{{file.name}}\"\nContent-Type: {{file.type}}\n\n{{file.content}}\n--boundary--",
"placeholders": [
{
"name": "file",
"type": "File",
"description": "The file to upload.",
"required": true
},
{
"name": "accessToken",
"type": "String",
"description": "The access token for Canva API.",
"required": true
}
]
},
"queryParams": {
"folder_id": "{{folderId}}"
}
}
}
]
}
```
The Autofill Design From Brand Template action in Canva automatically applies your brand’s colors, fonts, and logos to a new design based on a saved template.
{% embed url="" %}
#### Example User Story
I want to create a new flyer for our event without starting from scratch, so I use Autofill Design From Brand Template in Canva to instantly apply our brand’s colors, fonts, and logo to a pre-made template.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| templateId | String | Yes |
| designData | Map | Yes |
| designId | String | No |
| designUrl | String | No |
### Related Connections
[Canva](/canva/canva)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "autofill-design-from-brand-template",
"state": "inDev",
"meta": {
"short": "Autofill Design From Brand Template",
"description": "Automatically populate a design using a predefined brand template in Canva."
},
"input": [
{
"name": "templateId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the brand template to use."
}
},
{
"name": "designData",
"type": "Map",
"required": true,
"meta": {
"description": "A map of key-value pairs to populate the template fields."
}
}
],
"output": [
{
"name": "designId",
"type": "String",
"selector": ["response", "designId"],
"meta": {
"description": "The ID of the newly created design."
}
},
{
"name": "designUrl",
"type": "String",
"selector": ["response", "designUrl"],
"meta": {
"description": "The URL to access the newly created design."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/templates/{{templateId}}/autofill",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"data\": {{designData}}}",
"placeholders": [
{
"name": "designData",
"type": "Map",
"description": "Data to populate the template.",
"required": true
}
]
}
}
}
]
}
```
The Import Design action in Canva lets you bring in existing designs or files from other platforms to edit or repurpose.
{% embed url="" %}
#### Example User Story
I want to update last month’s presentation with new data, so I use Import Design in Canva to quickly bring in the old slides and make my edits.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| designURL | String | Yes |
| folderID | String | No |
### Related Connections
[Canva](/canva/canva)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "import-design",
"state": "inDev",
"meta": {
"short": "Import Design",
"description": "Import a design into Canva from an external source."
},
"input": [
{
"name": "designURL",
"type": "String",
"required": true,
"meta": {
"description": "URL of the design to import."
}
},
{
"name": "folderID",
"type": "String",
"required": false,
"meta": {
"description": "ID of the folder where the design will be saved."
}
}
],
"output": [
{
"name": "designID",
"type": "String",
"selector": ["data", "id"],
"meta": {
"description": "ID of the imported design."
}
},
{
"name": "status",
"type": "String",
"selector": ["data", "status"],
"meta": {
"description": "Status of the import operation."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v1/designs/import",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"design_url\": \"{{designURL}}\", \"folder_id\": \"{{folderID}}\"}",
"placeholders": [
{
"name": "designURL",
"type": "String",
"description": "URL of the design to import.",
"required": true
},
{
"name": "folderID",
"type": "String",
"description": "ID of the folder where the design will be saved.",
"required": false
}
]
}
}
}
]
}
```
The Archive or Delete Task action removes a task by either archiving or permanently deleting it.
{% embed url="" %}
#### Example User Story
I want to archive or delete a task in ClickUp so that I can keep my project board organized and up-to-date.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| taskID | String | Yes |
| actionType | String | Yes |
### Related Connections
[ClickUp](/clickup/clickup)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "archive-or-delete-task",
"state": "inDev",
"meta": {
"short": "Archive or Delete Task",
"description": "Archives or deletes a task in ClickUp based on the provided task ID and action type."
},
"input": [
{
"name": "taskID",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the task to archive or delete."
}
},
{
"name": "actionType",
"type": "String",
"required": true,
"meta": {
"description": "The action to perform. Must be either 'archive' or 'delete'.",
"options": ["archive", "delete"]
}
}
],
"output": [
{
"name": "success",
"type": "Boolean",
"selector": ["success"],
"meta": {
"description": "Indicates whether the operation was successful."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "DELETE",
"path": "/api/v2/task/{{taskID}}",
"headers": {
"Content-Type": "application/json"
},
"queryParams": {
"custom_task_ids": "true",
"team_id": "{{ClickUpTeamID}}"
},
"bodyTemplate": {
"value": "{\"archive\": {{actionType == 'archive'}}}",
"placeholders": [
{
"name": "actionType",
"type": "String",
"description": "The action to perform.",
"required": true,
"options": ["archive", "delete"]
}
]
}
}
}
]
}
```
The Send Direct Message action transmits a private message to a specified user.
{% embed url="" %}
#### Example User Story
I want to send a direct message to a team member in ClickUp so that I can quickly communicate updates or reminders.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| userId | String | Yes |
| message | String | Yes |
| teamId | String | No |
### Related Connections
[ClickUp](/clickup/clickup)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "send-direct-message",
"state": "inDev",
"meta": {
"short": "Send Direct Message",
"description": "Send a direct message to a user or team in ClickUp"
},
"input": [
{
"name": "userId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the user to send the message to"
}
},
{
"name": "message",
"type": "String",
"required": true,
"meta": {
"description": "The content of the message to send"
}
},
{
"name": "teamId",
"type": "String",
"required": false,
"meta": {
"description": "The ID of the team to send the message to (optional)"
}
}
],
"output": [
{
"name": "success",
"type": "Boolean",
"selector": ["success"],
"meta": {
"description": "Indicates if the message was sent successfully"
}
},
{
"name": "messageId",
"type": "String",
"selector": ["data", "id"],
"meta": {
"description": "The ID of the sent message"
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/api/v2/chat/message",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"user_id\": \"{{userId}}\", \"message\": \"{{message}}\", \"team_id\": \"{{teamId}}\"}",
"placeholders": [
{
"name": "userId",
"type": "String",
"description": "The ID of the user to send the message to",
"required": true
},
{
"name": "message",
"type": "String",
"description": "The content of the message to send",
"required": true
},
{
"name": "teamId",
"type": "String",
"description": "The ID of the team to send the message to (optional)",
"required": false
}
]
}
}
}
]
}
```
The Create new Document action generates a new document within a specified location.
{% embed url="" %}
#### Example User Story
I want to create a new document in ClickUp so that I can store and share project-related information with my team.
#### Fields
| Field Name | Field Type | Required |
| ------------- | ---------- | -------- |
| folder\_id | String | Yes |
| name | String | Yes |
| content | String | No |
| document\_id | String | No |
| document\_url | String | No |
### Related Connections
[ClickUp](/clickup/clickup)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "create-new-document",
"state": "inDev",
"meta": {
"short": "Create New Document",
"description": "Creates a new document in ClickUp."
},
"input": [
{
"name": "folder_id",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the folder where the document will be created."
}
},
{
"name": "name",
"type": "String",
"required": true,
"meta": {
"description": "The name of the document."
}
},
{
"name": "content",
"type": "String",
"required": false,
"meta": {
"description": "The content of the document."
}
}
],
"output": [
{
"name": "document_id",
"type": "String",
"selector": ["id"],
"meta": {
"description": "The ID of the created document."
}
},
{
"name": "document_url",
"type": "String",
"selector": ["url"],
"meta": {
"description": "The URL of the created document."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/folder/{{folder_id}}/document",
"headers": {
"Content-Type": "application/json",
"Authorization": "Bearer {{access_token}}"
},
"bodyTemplate": {
"value": "{\"name\":\"{{name}}\",\"content\":\"{{content}}\"}",
"placeholders": [
{
"name": "name",
"type": "String",
"description": "The name of the document.",
"required": true
},
{
"name": "content",
"type": "String",
"description": "The content of the document.",
"required": false
}
]
}
}
}
]
}
```
The Create Space action creates a new Space (a high-level container for organizing work).
{% embed url="" %}
#### Example User Story
I want to create a new space in ClickUp so that I can organize my team's tasks and projects effectively.
#### Fields
| Field Name | Field Type | Required |
| ------------------- | ---------- | -------- |
| name | String | Yes |
| multipleAssignments | Boolean | No |
| features | Object | No |
| spaceID | String | No |
| spaceName | String | No |
### Related Connections
[ClickUp](/clickup/clickup)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "create-space",
"state": "inDev",
"meta": {
"short": "Create Space",
"description": "Creates a new space in ClickUp."
},
"input": [
{
"name": "name",
"type": "String",
"required": true,
"meta": {
"description": "Name of the space to create."
}
},
{
"name": "multipleAssignments",
"type": "Boolean",
"required": false,
"meta": {
"description": "Whether multiple assignments are allowed in the space."
}
},
{
"name": "features",
"type": "Object",
"required": false,
"meta": {
"description": "Features enabled in the space."
}
}
],
"output": [
{
"name": "spaceID",
"type": "String",
"selector": ["id"],
"meta": {
"description": "ID of the created space."
}
},
{
"name": "spaceName",
"type": "String",
"selector": ["name"],
"meta": {
"description": "Name of the created space."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/team/{{teamID}}/space",
"headers": {
"Content-Type": "application/json",
"Authorization": "Bearer {{accessToken}}"
},
"bodyTemplate": {
"value": "{\"name\":\"{{name}}\",\"multiple_assignments\":{{multipleAssignments}},\"features\":{{features}}}",
"placeholders": [
{
"name": "name",
"type": "String",
"description": "Name of the space to create.",
"required": true
},
{
"name": "multipleAssignments",
"type": "Boolean",
"description": "Whether multiple assignments are allowed in the space.",
"required": false
},
{
"name": "features",
"type": "Object",
"description": "Features enabled in the space.",
"required": false
}
]
}
}
}
]
}
```
The Analyze Images action processes and analyzes images (e.g., for content, objects, or metadata).
{% embed url="" %}
#### Example User Story
I want to analyze images using an external service so that I can extract features like objects, faces, and text from the images.
#### Fields
| Field Name | Field Type | Required |
| -------------- | ---------- | -------- |
| imageUrl | String | Yes |
| features | String | No |
| analysisResult | String | No |
### Related Connections
[ChatGPT](/chatgpt/chatgpt)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "analyze-images",
"state": "inDev",
"meta": {
"short": "Analyze Images",
"description": "Analyze images using an external service."
},
"input": [
{
"name": "imageUrl",
"type": "String",
"required": true,
"meta": {
"description": "URL of the image to analyze."
}
},
{
"name": "features",
"type": "String",
"required": false,
"meta": {
"description": "Features to analyze in the image, e.g., objects, faces, text."
}
}
],
"output": [
{
"name": "analysisResult",
"type": "String",
"selector": ["result"],
"meta": {
"description": "The analysis result from the external service."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v1/vision/analyze",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"imageUrl\": \"{{imageUrl}}\", \"features\": \"{{features}}\"}",
"placeholders": [
{
"name": "imageUrl",
"type": "String",
"description": "URL of the image to analyze.",
"required": true
},
{
"name": "features",
"type": "String",
"description": "Features to analyze in the image.",
"required": false
}
]
}
}
}
]
}
```
The Analyze Text action processes and analyzes text content (e.g., for sentiment, keywords, or structure).
{% embed url="" %}
#### Example User Story
I want to analyze text using ChatGPT so that I can quickly extract insights or summarize content.
#### Fields
| Field Name | Field Type | Required |
| ------------ | ---------- | -------- |
| text | String | Yes |
| analysisType | String | No |
### Related Connections
[ChatGPT](/chatgpt/chatgpt)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "analyze-text",
"state": "inDev",
"meta": {
"short": "Analyze Text",
"description": "Analyze the given text using ChatGPT to extract insights, summarize content, or perform other text analysis tasks."
},
"input": [
{
"name": "text",
"type": "String",
"required": true,
"meta": {
"description": "The text to be analyzed."
}
},
{
"name": "analysisType",
"type": "String",
"required": false,
"meta": {
"description": "The type of analysis to perform (e.g., summarize, sentiment, entities).",
"default": "summarize"
}
}
],
"output": [
{
"name": "result",
"type": "String",
"selector": ["choices", "0", "message", "content"],
"meta": {
"description": "The analyzed result from ChatGPT."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v1/chat/completions",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"model\": \"gpt-3.5-turbo\", \"messages\": [{\"role\": \"user\", \"content\": \"Analyze the following text: {{text}}. Perform {{analysisType}} analysis.\"}]}",
"placeholders": [
{
"name": "text",
"type": "String",
"description": "The text to be analyzed.",
"required": true
},
{
"name": "analysisType",
"type": "String",
"description": "The type of analysis to perform.",
"required": false,
"default": "summarize"
}
]
}
}
}
]
}
```
The Create Embedding action generates a vector embedding (numerical representation) from input text.
{% embed url="" %}
#### Example User Story
I want to generate an embedding for a given input text so that I can use it for machine learning tasks.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| input | String | Yes |
### Related Connections
[ChatGPT](/chatgpt/chatgpt)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "create-embedding",
"state": "inDev",
"meta": {
"short": "Create Embedding",
"description": "Generate an embedding for a given input text using the external service."
},
"input": [
{
"name": "input",
"type": "String",
"required": true,
"meta": {
"description": "The input text to generate an embedding for."
}
}
],
"output": [
{
"name": "embedding",
"type": "Array",
"selector": ["data", "embedding"],
"meta": {
"description": "The generated embedding for the input text."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v1/embeddings",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"input\": \"{{input}}\", \"model\": \"text-embedding-ada-002\"}",
"placeholders": [
{
"name": "input",
"type": "String",
"description": "The input text to generate an embedding for.",
"required": true
}
]
}
}
}
]
}
```
The Create Transcription action converts audio or video files into written text.
{% embed url="" %}
#### Example User Story
I want to transcribe an audio file so that I can have a text version of the audio content.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| audioFile | String | Yes |
| language | String | No |
### Related Connections
[ChatGPT](/chatgpt/chatgpt)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "create-transcription",
"state": "inDev",
"meta": {
"short": "Create Transcription",
"description": "Creates a transcription from an audio file using the OpenAI Whisper API."
},
"input": [
{
"name": "audioFile",
"type": "String",
"required": true,
"meta": {
"description": "The audio file to transcribe."
}
},
{
"name": "language",
"type": "String",
"required": false,
"meta": {
"description": "The language of the audio file (optional)."
}
}
],
"output": [
{
"name": "transcription",
"type": "String",
"selector": ["transcription"],
"meta": {
"description": "The transcribed text from the audio file."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v1/audio/transcriptions",
"headers": {
"Content-Type": "multipart/form-data"
},
"bodyTemplate": {
"value": "--boundary\nContent-Disposition: form-data; name=\"file\"; filename=\"audio.mp3\"\nContent-Type: audio/mpeg\n\n{{audioFile}}\n--boundary\nContent-Disposition: form-data; name=\"language\"\n\n{{language}}\n--boundary--",
"placeholders": [
{
"name": "audioFile",
"type": "String",
"description": "The audio file to transcribe.",
"required": true
},
{
"name": "language",
"type": "String",
"description": "The language of the audio file (optional).",
"required": false
}
]
}
}
}
]
}
```
Send chat-style messages to Claude for conversational and task-oriented interactions
{% embed url="" %}
#### Example User Story
As a user, I want to send a message using the Claude API so that I can generate responses based on my prompts.
#### Fields
| Field Name | Field Type | Required |
| ----------- | ---------- | -------- |
| model | String | Yes |
| prompt | String | Yes |
| max\_tokens | Integer | No |
### Related Connections
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "send-message",
"state": "inDev",
"meta": {
"short": "Send Message",
"description": "Send a message using the Claude API"
},
"input": [
{
"name": "model",
"type": "String",
"required": true,
"meta": {
"description": "The model to use for generating the message"
}
},
{
"name": "prompt",
"type": "String",
"required": true,
"meta": {
"description": "The prompt to send to the model"
}
},
{
"name": "max_tokens",
"type": "Integer",
"required": false,
"meta": {
"description": "The maximum number of tokens to generate"
}
}
],
"output": [
{
"name": "response",
"type": "String",
"selector": ["completion"],
"meta": {
"description": "The generated message response"
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v1/message",
"headers": {
"Content-Type": "application/json",
"x-api-key": "{{.apiKey}}"
},
"bodyTemplate": {
"value": "{\"model\": \"{{.model}}\", \"prompt\": \"{{.prompt}}\", \"max_tokens\": {{.max_tokens}}}",
"placeholders": [
{
"name": "model",
"type": "String",
"description": "The model to use for generating the message",
"required": true
},
{
"name": "prompt",
"type": "String",
"description": "The prompt to send to the model",
"required": true
},
{
"name": "max_tokens",
"type": "Integer",
"description": "The maximum number of tokens to generate",
"required": false
}
]
}
}
}
]
}
```
Estimate token usage for a given prompt or conversation before actually calling the model, to manage cost and respect rate limits
{% embed url="" %}
#### Example User Story
As a user, I want to count the number of tokens in my text so that I can ensure it fits within the allowed limit for the Claude API.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| text | String | Yes |
### Related Connections
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "count-tokens",
"state": "inDev",
"meta": {
"short": "Count Tokens",
"description": "Counts the number of tokens in a given text using the Claude API."
},
"input": [
{
"name": "text",
"type": "String",
"required": true,
"meta": {
"description": "The text to count tokens for."
}
}
],
"output": [
{
"name": "tokenCount",
"type": "Integer",
"selector": ["count"],
"meta": {
"description": "The number of tokens in the provided text."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v1/messages/count_tokens",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"text\": \"{{text}}\"}",
"placeholders": [
{
"name": "text",
"type": "String",
"description": "The text to count tokens for.",
"required": true
}
]
}
}
}
]
}
```
{% embed url="" %}
#### Example User Story
As a developer, I want to upload a file to the Claude API so that I can use it for fine-tuning or other purposes.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| file | File | Yes |
| purpose | String | No |
### Related Connections
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "upload-file",
"state": "inDev",
"meta": {
"short": "Upload File",
"description": "Uploads a file to the Claude API."
},
"input": [
{
"name": "file",
"type": "File",
"required": true,
"meta": {
"description": "The file to upload."
}
},
{
"name": "purpose",
"type": "String",
"required": false,
"meta": {
"description": "The intended purpose of the uploaded file.",
"default": "fine-tune"
}
}
],
"output": [
{
"name": "id",
"type": "String",
"selector": ["id"],
"meta": {
"description": "The unique identifier of the uploaded file."
}
},
{
"name": "status",
"type": "String",
"selector": ["status"],
"meta": {
"description": "The status of the uploaded file."
}
},
{
"name": "bytes",
"type": "Integer",
"selector": ["bytes"],
"meta": {
"description": "The size of the uploaded file in bytes."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v1/files",
"headers": {
"Content-Type": "multipart/form-data"
},
"bodyTemplate": {
"value": "--boundary\\r\\nContent-Disposition: form-data; name=\"file\"; filename=\"{{file.name}}\"\\r\\nContent-Type: {{file.type}}\\r\\n\\r\\n{{file.content}}\\r\\n--boundary--\\r\\n--boundary\\r\\nContent-Disposition: form-data; name=\"purpose\"\\r\\n\\r\\n{{purpose}}\\r\\n--boundary--",
"placeholders": [
{
"name": "file",
"type": "File",
"description": "The file to upload.",
"required": true
},
{
"name": "purpose",
"type": "String",
"description": "The intended purpose of the uploaded file.",
"required": false,
"default": "fine-tune"
}
]
}
}
}
]
}
```
{% embed url="" %}
#### Example User Story
As a user, I want to create a new skill in the Claude API so that I can automate specific tasks.
#### Fields
| Field Name | Field Type | Required |
| ------------ | ---------- | -------- |
| name | String | Yes |
| description | String | No |
| instructions | String | Yes |
### Related Connections
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "create-skill",
"state": "inDev",
"meta": {
"short": "Create Skill",
"description": "Creates a new skill in the Claude API."
},
"input": [
{
"name": "name",
"type": "String",
"required": true,
"meta": {
"description": "The name of the skill."
}
},
{
"name": "description",
"type": "String",
"required": false,
"meta": {
"description": "A description of the skill."
}
},
{
"name": "instructions",
"type": "String",
"required": true,
"meta": {
"description": "Instructions for the skill."
}
}
],
"output": [
{
"name": "skillId",
"type": "String",
"selector": ["id"],
"meta": {
"description": "The ID of the created skill."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v1/skills",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"name\": \"{{name}}\", \"description\": \"{{description}}\", \"instructions\": \"{{instructions}}\"}",
"placeholders": [
{
"name": "name",
"type": "String",
"description": "The name of the skill.",
"required": true
},
{
"name": "description",
"type": "String",
"description": "A description of the skill.",
"required": false
},
{
"name": "instructions",
"type": "String",
"description": "Instructions for the skill.",
"required": true
}
]
}
}
}
]
}
```
Retrieves a list of Claude models available from the Claude API
{% embed url="" %}
#### Example User Story
As a developer, I want to retrieve a list of available models from the Claude API so that I can choose the appropriate model for my application.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| models | Array | No |
### Related Connections
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "get-models",
"state": "inDev",
"meta": {
"short": "Get Models",
"description": "Retrieves a list of available models from the Claude API."
},
"input": [],
"output": [
{
"name": "models",
"type": "Array",
"selector": ["data"],
"meta": {}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/v1/models",
"headers": {
"Content-Type": "application/json",
"Accept": "application/json"
},
"queryParams": {},
"bodyTemplate": {
"value": ""
}
}
}
]
}
```
Retrives a list of files from the external service
{% embed url="" %}
#### Example User Story
As a user, I want to retrieve a list of files from the external service so that I can view and manage them.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| limit | Integer | No |
| offset | Integer | No |
### Related Connections
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "get-files",
"state": "inDev",
"meta": {
"short": "Get Files",
"description": "Retrieves a list of files from the external service."
},
"input": [
{
"name": "limit",
"type": "Integer",
"required": false,
"meta": {
"description": "Maximum number of files to return."
}
},
{
"name": "offset",
"type": "Integer",
"required": false,
"meta": {
"description": "Offset for pagination."
}
}
],
"output": [
{
"name": "files",
"type": "Array",
"selector": ["data"],
"meta": {
"description": "List of files retrieved from the service."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/v1/files",
"queryParams": {
"limit": "{{limit}}",
"offset": "{{offset}}"
}
}
}
]
}
```
Retrieves a list of skills available from the Claude API
{% embed url="" %}
#### Example User Story
As a developer, I want to retrieve a list of available skills from the Claude API so that I can integrate them into my application.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| apiKey | String | Yes |
### Related Connections
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
// Some code
{
"handle": "get-skills",
"state": "inDev",
"meta": {
"short": "Get Skills",
"description": "Retrieves a list of available skills from the Claude API."
},
"input": [
{
"name": "apiKey",
"type": "String",
"required": true,
"meta": {
"description": "The API key for authenticating with the Claude API."
}
}
],
"output": [
{
"name": "skills",
"type": "Array",
"selector": ["skills"],
"meta": {
"description": "List of available skills."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/v1/skills",
"headers": {
"Content-Type": "application/json"
}
}
}
]
}
```
The Add Role action in Discord assigns a specific role (and its permissions) to a user on a server.
{% embed url="" %}
#### Example User Story
I want to give new team members access to our project channels, so I use the Add Role action in Discord to assign them the "Project Contributor" role.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| guildId | String | Yes |
| userId | String | Yes |
| roleId | String | Yes |
### Related Connections
[Discord](/discord/discord)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "add-role",
"state": "inDev",
"meta": {
"short": "Add Role",
"description": "Adds a specified role to a user in a Discord server."
},
"input": [
{
"name": "guildId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the Discord server (guild)."
}
},
{
"name": "userId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the user to whom the role will be added."
}
},
{
"name": "roleId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the role to be added."
}
}
],
"output": [
{
"name": "success",
"type": "Boolean",
"selector": [],
"meta": {
"description": "Indicates whether the role was successfully added."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "PUT",
"path": "/guilds/{{guildId}}/members/{{userId}}/roles/{{roleId}}",
"headers": {
"Content-Type": "application/json"
}
}
}
]
}
```
The Remove User Role action in Discord revokes a specific role (and its permissions) from a user on a server.
{% embed url="" %}
#### Example User Story
I want to restrict a member’s access to admin channels after their project ends, so I use the Remove User Role action in Discord to take away their "Project Lead" role.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| guildID | String | Yes |
| userID | String | Yes |
| roleID | String | Yes |
| botToken | String | Yes |
### Related Connections
[Discord](/discord/discord)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "remove-user-role",
"state": "inDev",
"meta": {
"short": "Remove User Role",
"description": "Removes a specified role from a user in a Discord server."
},
"input": [
{
"name": "guildID",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the Discord server (guild)."
}
},
{
"name": "userID",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the user to remove the role from."
}
},
{
"name": "roleID",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the role to remove from the user."
}
},
{
"name": "botToken",
"type": "String",
"required": true,
"meta": {
"description": "The bot token for authenticating with the Discord API."
}
}
],
"output": [
{
"name": "success",
"type": "Boolean",
"selector": [],
"meta": {
"description": "Indicates whether the role was successfully removed."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "DELETE",
"path": "/guilds/{{guildID}}/members/{{userID}}/roles/{{roleID}}",
"headers": {
"Content-Type": "application/json"
}
}
}
]
}
```
The Send Channel Message action in Discord posts a message to a specified channel on a server.
{% embed url="" %}
#### Example User Story
I want to notify everyone about the upcoming team meeting, so I use the Send Channel Message action in Discord to post a reminder in the #announcements channel.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| channelID | String | Yes |
| message | String | Yes |
| embed | Object | No |
### Related Connections
[Discord](/discord/discord)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "send-channel-message",
"state": "inDev",
"meta": {
"short": "Send Channel Message",
"description": "Sends a message to a specified Discord channel."
},
"input": [
{
"name": "channelID",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the Discord channel to send the message to."
}
},
{
"name": "message",
"type": "String",
"required": true,
"meta": {
"description": "The content of the message to send."
}
},
{
"name": "embed",
"type": "Object",
"required": false,
"meta": {
"description": "An optional embed object to include in the message."
}
}
],
"output": [
{
"name": "messageID",
"type": "String",
"selector": ["id"],
"meta": {
"description": "The ID of the sent message."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/channels/{{channelID}}/messages",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"content\": \"{{message}}\", \"embed\": {{embed}}}",
"placeholders": [
{
"name": "message",
"type": "String",
"description": "The content of the message to send.",
"required": true
},
{
"name": "embed",
"type": "Object",
"description": "An optional embed object to include in the message.",
"required": false
}
]
}
}
}
]
}
```
The Send Message in Forum Post action in Discord allows you to reply or post a message within a specific forum thread.
{% embed url="" %}
#### Example User Story
I want to answer a team member’s question about the project timeline, so I use the Send Message in Forum Post action in Discord to reply directly in the relevant forum thread.
#### Fields
| Field Name | Field Type | Required |
| -------------- | ---------- | -------- |
| channelID | String | Yes |
| threadID | String | Yes |
| messageContent | String | Yes |
| messageID | String | No |
### Related Connections
[Discord](/discord/discord)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "send-forum-post-message",
"state": "inDev",
"meta": {
"short": "Send Message in Forum Post",
"description": "Send a message to a specific forum post in Discord."
},
"input": [
{
"name": "channelID",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the forum channel."
}
},
{
"name": "threadID",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the thread (forum post) where the message will be sent."
}
},
{
"name": "messageContent",
"type": "String",
"required": true,
"meta": {
"description": "The content of the message to be sent."
}
}
],
"output": [
{
"name": "messageID",
"type": "String",
"selector": ["id"],
"meta": {
"description": "The ID of the sent message."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/channels/{{channelID}}/messages",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"content\": \"{{messageContent}}\", \"message_reference\": {\"channel_id\": \"{{channelID}}\", \"message_id\": \"{{threadID}}\"}}",
"placeholders": [
{
"name": "channelID",
"type": "String",
"description": "The ID of the forum channel.",
"required": true
},
{
"name": "threadID",
"type": "String",
"description": "The ID of the thread (forum post).",
"required": true
},
{
"name": "messageContent",
"type": "String",
"description": "The content of the message to be sent.",
"required": true
}
]
}
}
}
]
}
```
The Add Document to Workspace action uploads a file to a specified DocuSign workspace for storage or further processing.
{% embed url="" %}
#### Example User Story
I want to automatically add signed contracts to our team’s DocuSign workspace, so everyone can access and review them in one place.
#### Fields
| Field Name | Field Type | Required |
| --------------- | ---------- | -------- |
| workspaceId | String | Yes |
| documentName | String | Yes |
| documentContent | String | Yes |
| accessToken | String | Yes |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "add-document-to-workspace",
"state": "inDev",
"meta": {
"short": "Add Document to Workspace",
"description": "Uploads a document to a specified Docusign workspace."
},
"input": [
{
"name": "workspaceId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the workspace where the document will be added."
}
},
{
"name": "documentName",
"type": "String",
"required": true,
"meta": {
"description": "The name of the document to be uploaded."
}
},
{
"name": "documentContent",
"type": "String",
"required": true,
"meta": {
"description": "Base64 encoded content of the document."
}
}
],
"output": [
{
"name": "documentId",
"type": "String",
"selector": ["documentId"],
"meta": {
"description": "The ID of the uploaded document."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v2.1/workspaces/{{workspaceId}}/folders",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"name\": \"{{documentName}}\", \"content\": \"{{documentContent}}\"}",
"placeholders": [
{
"name": "workspaceId",
"type": "String",
"description": "The ID of the workspace where the document will be added.",
"required": true
},
{
"name": "documentName",
"type": "String",
"description": "The name of the document to be uploaded.",
"required": true
},
{
"name": "documentContent",
"type": "String",
"description": "Base64 encoded content of the document.",
"required": true
},
{
"name": "accessToken",
"type": "String",
"description": "Access token for Docusign API authentication.",
"required": true
}
]
}
}
}
]
}
```
The Add User to Workspace action grants a new user access to a specific DocuSign workspace.
{% embed url="" %}
#### Example User Story
I want to add new team members to our DocuSign workspace automatically, so they can immediately access and collaborate on documents.
#### Fields
| Field Name | Field Type | Required |
| ------------------- | ---------- | -------- |
| workspaceId | String | Yes |
| userId | String | Yes |
| permissionProfileId | String | Yes |
| accessToken | String | Yes |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "add-user-to-workspace",
"state": "inDev",
"meta": {
"short": "Add User to Workspace",
"description": "Adds a user to a specified workspace in DocuSign."
},
"input": [
{
"name": "workspaceId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the workspace to which the user will be added."
}
},
{
"name": "userId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the user to be added to the workspace."
}
},
{
"name": "permissionProfileId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the permission profile to assign to the user."
}
}
],
"output": [
{
"name": "success",
"type": "Boolean",
"selector": ["success"],
"meta": {
"description": "Indicates whether the operation was successful."
}
},
{
"name": "workspaceUserId",
"type": "String",
"selector": ["workspaceUserId"],
"meta": {
"description": "The ID of the newly created workspace user association."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v2.1/workspaces/{{workspaceId}}/users",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"userId\": \"{{userId}}\", \"permissionProfileId\": \"{{permissionProfileId}}\"}",
"placeholders": [
{
"name": "accessToken",
"type": "String",
"description": "The access token for authenticating with the DocuSign API.",
"required": true
},
{
"name": "workspaceId",
"type": "String",
"description": "The ID of the workspace to which the user will be added.",
"required": true
},
{
"name": "userId",
"type": "String",
"description": "The ID of the user to be added to the workspace.",
"required": true
},
{
"name": "permissionProfileId",
"type": "String",
"description": "The ID of the permission profile to assign to the user.",
"required": true
}
]
}
}
}
]
}
```
The Create Envelope From Workspace action generates a new signing envelope using documents already stored in a DocuSign workspace.
{% embed url="" %}
#### Example User Story
I want to create a signing envelope from our DocuSign workspace templates, so I can quickly send contracts to new clients without re-uploading files.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| templateId | String | Yes |
| status | String | No |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "create-envelope-from-workspace",
"state": "inDev",
"meta": {
"short": "Create Envelope From Workspace",
"description": "Creates an envelope from a template in a Docusign workspace."
},
"input": [
{
"name": "templateId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the template to use for the envelope."
}
},
{
"name": "status",
"type": "String",
"required": false,
"meta": {
"description": "The status of the envelope. Default is 'sent'.",
"default": "sent"
}
}
],
"output": [
{
"name": "envelopeId",
"type": "String",
"selector": ["envelopeId"],
"meta": {
"description": "The ID of the created envelope."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v2.1/accounts/{{accountId}}/envelopes",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"status\":\"{{status}}\",\"templateId\":\"{{templateId}}\"}",
"placeholders": [
{
"name": "status",
"type": "String",
"description": "The status of the envelope.",
"required": false,
"default": "sent"
},
{
"name": "templateId",
"type": "String",
"description": "The ID of the template to use for the envelope.",
"required": true
}
]
}
}
}
]
}
```
The Create Workspace action sets up a new shared folder in DocuSign for organizing and collaborating on documents.
{% embed url="" %}
#### Example User Story
I want to create a dedicated DocuSign workspace for each new project, so my team can securely store and manage all related contracts in one place.
#### Fields
| Field Name | Field Type | Required |
| ----------- | ---------- | -------- |
| name | String | Yes |
| description | String | No |
| billable | Boolean | No |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "create-workspace",
"state": "inDev",
"meta": {
"short": "Create Workspace",
"description": "Creates a new workspace in Docusign."
},
"input": [
{
"name": "name",
"type": "String",
"required": true,
"meta": {
"description": "The name of the workspace."
}
},
{
"name": "description",
"type": "String",
"required": false,
"meta": {
"description": "The description of the workspace."
}
},
{
"name": "billable",
"type": "Boolean",
"required": false,
"meta": {
"description": "Whether the workspace is billable."
}
}
],
"output": [
{
"name": "workspaceId",
"type": "String",
"selector": ["workspaceId"],
"meta": {
"description": "The ID of the created workspace."
}
},
{
"name": "name",
"type": "String",
"selector": ["name"],
"meta": {
"description": "The name of the created workspace."
}
},
{
"name": "description",
"type": "String",
"selector": ["description"],
"meta": {
"description": "The description of the created workspace."
}
},
{
"name": "billable",
"type": "Boolean",
"selector": ["billable"],
"meta": {
"description": "Whether the created workspace is billable."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v2.1/workspaces",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"name\": \"{{name}}\", \"description\": \"{{description}}\", \"billable\": {{billable}}}",
"placeholders": [
{
"name": "name",
"type": "String",
"description": "The name of the workspace.",
"required": true
},
{
"name": "description",
"type": "String",
"description": "The description of the workspace.",
"required": false
},
{
"name": "billable",
"type": "Boolean",
"description": "Whether the workspace is billable.",
"required": false
}
]
}
}
}
]
}
```
The Send Envelope Using Template action generates and sends a signing request using a pre-made DocuSign template.
{% embed url="" %}
#### Example User Story
I want to send onboarding agreements using our DocuSign template, so new hires can sign all required documents quickly and consistently.
#### Fields
| Field Name | Field Type | Required |
| -------------- | ---------- | -------- |
| templateId | String | Yes |
| recipientEmail | String | Yes |
| recipientName | String | Yes |
| status | String | No |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "send-envelope-using-template",
"state": "inDev",
"meta": {
"short": "Send Envelope Using Template",
"description": "Sends an envelope using a specified template in DocuSign."
},
"input": [
{
"name": "templateId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the template to use for the envelope."
}
},
{
"name": "recipientEmail",
"type": "String",
"required": true,
"meta": {
"description": "The email address of the recipient."
}
},
{
"name": "recipientName",
"type": "String",
"required": true,
"meta": {
"description": "The name of the recipient."
}
},
{
"name": "status",
"type": "String",
"required": false,
"meta": {
"description": "The status of the envelope (e.g., 'sent', 'created').",
"default": "sent"
}
}
],
"output": [
{
"name": "envelopeId",
"type": "String",
"selector": ["envelopeId"],
"meta": {
"description": "The ID of the created envelope."
}
},
{
"name": "status",
"type": "String",
"selector": ["status"],
"meta": {
"description": "The status of the envelope."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v2.1/accounts/{{accountId}}/envelopes",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"templateId\":\"{{templateId}}\",\"status\":\"{{status}}\",\"templateRoles\":[{\"email\":\"{{recipientEmail}}\",\"name\":\"{{recipientName}}\",\"roleName\":\"signer\"}]}",
"placeholders": [
{
"name": "templateId",
"type": "String",
"description": "The ID of the template to use for the envelope.",
"required": true
},
{
"name": "status",
"type": "String",
"description": "The status of the envelope.",
"required": false,
"default": "sent"
},
{
"name": "recipientEmail",
"type": "String",
"description": "The email address of the recipient.",
"required": true
},
{
"name": "recipientName",
"type": "String",
"description": "The name of the recipient.",
"required": true
}
]
}
}
}
]
}
```
The Create Pre-Filled Webform Link action generates a shareable link to a Docusign form with pre-populated fields for faster recipient completion.
{% embed url="" %}
#### Example User Story
I want to create a pre-filled webform link so recipients can quickly sign agreements without manually entering repeated data like names or addresses.
#### Fields
| Field Name | Field Type | Required |
| ----------- | ---------- | -------- |
| envelopeId | String | Yes |
| recipientId | String | Yes |
| returnUrl | String | No |
| url | String | No |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "create-pre-filled-webform-link",
"state": "inDev",
"meta": {
"short": "Create Pre-Filled Webform Link",
"description": "Generates a pre-filled webform link for a DocuSign envelope."
},
"input": [
{
"name": "envelopeId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the envelope for which the webform link is generated."
}
},
{
"name": "recipientId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the recipient for the webform link."
}
},
{
"name": "returnUrl",
"type": "String",
"required": false,
"meta": {
"description": "The URL to redirect to after the webform is completed."
}
}
],
"output": [
{
"name": "url",
"type": "String",
"selector": ["url"],
"meta": {
"description": "The generated pre-filled webform link."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v2.1/accounts/{{accountId}}/envelopes/{{envelopeId}}/views/recipient",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"returnUrl\": \"{{returnUrl}}\", \"authenticationMethod\": \"none\", \"recipientId\": \"{{recipientId}}\", \"userName\": \"{{userName}}\", \"email\": \"{{email}}\"}",
"placeholders": [
{
"name": "returnUrl",
"type": "String",
"description": "The URL to redirect to after the webform is completed.",
"required": false
},
{
"name": "recipientId",
"type": "String",
"description": "The ID of the recipient for the webform link.",
"required": true
},
{
"name": "userName",
"type": "String",
"description": "The name of the recipient.",
"required": true
},
{
"name": "email",
"type": "String",
"description": "The email of the recipient.",
"required": true
}
]
}
}
}
]
}
```
The Cancel Maestro Workflow Instance action stops an in-progress Maestro workflow, halting any further processing or notifications.
{% embed url="" %}
#### Example User Story
I want to revoke access for former team members from our DocuSign workspaces, so only current employees can view or edit sensitive documents.
#### Fields
| Field Name | Field Type | Required |
| ----------- | ---------- | -------- |
| workspaceId | String | Yes |
| userId | String | Yes |
| accessToken | String | Yes |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "revoke-workspace-user-access",
"state": "inDev",
"meta": {
"short": "Revoke Workspace User Access",
"description": "Revokes a user's access to a specific workspace in DocuSign."
},
"input": [
{
"name": "workspaceId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the workspace from which to revoke user access."
}
},
{
"name": "userId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the user whose access is to be revoked."
}
}
],
"output": [
{
"name": "success",
"type": "Boolean",
"selector": ["success"],
"meta": {
"description": "Indicates whether the operation was successful."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "DELETE",
"path": "/v2.1/workspaces/{{workspaceId}}/users/{{userId}}",
"headers": {
"Content-Type": "application/json"
}
}
}
]
}
```
The Test Bulk Send Request action validates a bulk send list and settings before actually sending envelopes, ensuring everything is configured correctly.
{% embed url="" %}
#### Example User Story
I want to test my bulk send request in DocuSign before sending, so I can confirm all recipient details and documents are correct.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| accountId | String | Yes |
| templateId | String | Yes |
| recipients | Array | Yes |
| status | String | No |
| bulkSendId | String | No |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "test-bulk-send-request",
"state": "inDev",
"meta": {
"short": "Test Bulk Send Request",
"description": "Send a bulk request to Docusign for testing purposes."
},
"input": [
{
"name": "accountId",
"type": "String",
"required": true,
"meta": {
"description": "The Docusign account ID."
}
},
{
"name": "templateId",
"type": "String",
"required": true,
"meta": {
"description": "The Docusign template ID to use for the bulk send."
}
},
{
"name": "recipients",
"type": "Array",
"required": true,
"meta": {
"description": "List of recipient details for the bulk send."
}
}
],
"output": [
{
"name": "status",
"type": "String",
"selector": ["status"],
"meta": {
"description": "The status of the bulk send request."
}
},
{
"name": "bulkSendId",
"type": "String",
"selector": ["bulkSendId"],
"meta": {
"description": "The ID of the created bulk send request."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v2.1/accounts/{{accountId}}/bulk_send",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"templateId\": \"{{templateId}}\", \"recipients\": {{recipients}}}",
"placeholders": [
{
"name": "templateId",
"type": "String",
"description": "The Docusign template ID.",
"required": true
},
{
"name": "recipients",
"type": "Array",
"description": "List of recipient details.",
"required": true
}
]
}
}
}
]
}
```
The Add to Bulk Send List action includes recipients and documents in a bulk send queue for mass distribution.
{% embed url="" %}
#### Example User Story
I want to add all new clients to a bulk send list in DocuSign, so I can efficiently send welcome packets to everyone at once.
#### Fields
| Field Name | Field Type | Required |
| -------------- | ---------- | -------- |
| bulkSendListId | String | Yes |
| envelopeId | String | Yes |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "add-to-bulk-send-list",
"state": "inDev",
"meta": {
"short": "Add to Bulk Send List",
"description": "Adds an envelope to a bulk send list in Docusign."
},
"input": [
{
"name": "bulkSendListId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the bulk send list."
}
},
{
"name": "envelopeId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the envelope to add to the bulk send list."
}
}
],
"output": [
{
"name": "success",
"type": "Boolean",
"selector": ["success"],
"meta": {
"description": "Indicates whether the operation was successful."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v2.1/accounts/{{accountId}}/bulk_send_lists/{{bulkSendListId}}/envelopes",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"envelopeId\": \"{{envelopeId}}\"}",
"placeholders": [
{
"name": "envelopeId",
"type": "String",
"description": "The ID of the envelope to add to the bulk send list.",
"required": true
}
]
}
}
}
]
}
```
The Bulk Send Envelope From Template action sends personalized envelopes to multiple recipients using a single template.
{% embed url="" %}
#### Example User Story
I want to bulk send personalized onboarding contracts from a template to 50 new employees, so each receives their tailored agreement automatically.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| templateId | String | Yes |
| recipients | Array | Yes |
| status | String | No |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "bulk-send-envelope-from-template",
"state": "inDev",
"meta": {
"short": "Bulk Send Envelope From Template",
"description": "Sends an envelope to multiple recipients using a template."
},
"input": [
{
"name": "templateId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the template to use for the envelope."
}
},
{
"name": "recipients",
"type": "Array",
"required": true,
"meta": {
"description": "List of recipient objects, each containing email, name, and roleName."
}
},
{
"name": "status",
"type": "String",
"required": false,
"meta": {
"description": "The status of the envelope. Default is 'sent'.",
"default": "sent"
}
}
],
"output": [
{
"name": "envelopeId",
"type": "String",
"selector": ["envelopeId"],
"meta": {
"description": "The ID of the created envelope."
}
},
{
"name": "status",
"type": "String",
"selector": ["status"],
"meta": {
"description": "The status of the envelope."
}
},
{
"name": "uri",
"type": "String",
"selector": ["uri"],
"meta": {
"description": "The URI of the created envelope."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v2.1/accounts/{{accountId}}/envelopes",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"templateId\":\"{{templateId}}\",\"status\":\"{{status}}\",\"templateRoles\":{{recipients}}}",
"placeholders": [
{
"name": "templateId",
"type": "String",
"description": "The ID of the template to use for the envelope.",
"required": true
},
{
"name": "status",
"type": "String",
"description": "The status of the envelope.",
"required": false,
"default": "sent"
},
{
"name": "recipients",
"type": "String",
"description": "JSON array of recipient objects.",
"required": true
}
]
}
}
}
]
}
```
The Create Draft Signature Request action prepares a new envelope in Docusign with documents and recipients but does not send it yet, allowing for review or modifications before sending.
{% embed url="" %}
#### Example User Story
I want to create a draft signature request so I can review and adjust the documents and recipients before sending it out for signatures.
#### Fields
| Field Name | Field Type | Required |
| ----------- | ---------- | -------- |
| templateId | String | Yes |
| signerEmail | String | Yes |
| signerName | String | Yes |
| subject | String | No |
| message | String | No |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "create-draft-signature-request",
"state": "inDev",
"meta": {
"short": "Create Draft Signature Request",
"description": "Creates a draft signature request in DocuSign"
},
"input": [
{
"name": "templateId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the template to use for the signature request"
}
},
{
"name": "signerEmail",
"type": "String",
"required": true,
"meta": {
"description": "The email of the signer"
}
},
{
"name": "signerName",
"type": "String",
"required": true,
"meta": {
"description": "The name of the signer"
}
},
{
"name": "subject",
"type": "String",
"required": false,
"meta": {
"description": "The subject of the signature request email"
}
},
{
"name": "message",
"type": "String",
"required": false,
"meta": {
"description": "The message body of the signature request email"
}
}
],
"output": [
{
"name": "envelopeId",
"type": "String",
"selector": ["envelopeId"],
"meta": {
"description": "The ID of the created envelope"
}
},
{
"name": "status",
"type": "String",
"selector": ["status"],
"meta": {
"description": "The status of the created envelope"
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v2.1/accounts/{{accountId}}/envelopes",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"status\":\"created\",\"templateId\":\"{{templateId}}\",\"templateRoles\":[{\"email\":\"{{signerEmail}}\",\"name\":\"{{signerName}}\",\"roleName\":\"signer\"}],\"emailSubject\":\"{{subject}}\",\"emailBlurb\":\"{{message}}\"}",
"placeholders": [
{
"name": "templateId",
"type": "String",
"description": "The ID of the template to use for the signature request",
"required": true
},
{
"name": "signerEmail",
"type": "String",
"description": "The email of the signer",
"required": true
},
{
"name": "signerName",
"type": "String",
"description": "The name of the signer",
"required": true
},
{
"name": "subject",
"type": "String",
"description": "The subject of the signature request email",
"required": false
},
{
"name": "message",
"type": "String",
"description": "The message body of the signature request email",
"required": false
}
]
}
}
}
]
}
```
The Create Template from Document action converts an uploaded document into a reusable Docusign template with defined fields, recipients, and routing rules.
{% embed url="" %}
#### Example User Story
I want to create a template from a document so I can reuse it for future signature requests without rebuilding the form each time.
#### Fields
| Field Name | Field Type | Required |
| ------------------- | ---------- | -------- |
| accountId | String | Yes |
| documentId | String | Yes |
| templateName | String | Yes |
| templateDescription | String | No |
| templateId | String | - |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "create-template-from-document",
"state": "inDev",
"meta": {
"short": "Create Template from Document",
"description": "Creates a template from an existing document in DocuSign."
},
"input": [
{
"name": "accountId",
"type": "String",
"required": true,
"meta": {
"description": "The DocuSign account ID."
}
},
{
"name": "documentId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the document to convert into a template."
}
},
{
"name": "templateName",
"type": "String",
"required": true,
"meta": {
"description": "The name of the new template."
}
},
{
"name": "templateDescription",
"type": "String",
"required": false,
"meta": {
"description": "The description of the new template."
}
}
],
"output": [
{
"name": "templateId",
"type": "String",
"selector": ["templateId"],
"meta": {
"description": "The ID of the created template."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v2.1/accounts/{{accountId}}/templates",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"name\":\"{{templateName}}\",\"description\":\"{{templateDescription}}\",\"documents\":[{\"documentId\":\"{{documentId}}\"}]}",
"placeholders": [
{
"name": "templateName",
"type": "String",
"description": "The name of the new template.",
"required": true
},
{
"name": "templateDescription",
"type": "String",
"description": "The description of the new template.",
"required": false
},
{
"name": "documentId",
"type": "String",
"description": "The ID of the document to convert into a template.",
"required": true
}
]
}
}
}
]
}
```
The Delete Document From Workspace action permanently removes a specified document from a Docusign workspace.
{% embed url="" %}
#### Example User Story
I want to delete an outdated document from my workspace to keep my files organized and avoid confusion with current versions.
#### Fields
| Field Name | Field Type | Required |
| ----------- | ---------- | -------- |
| workspaceId | String | Yes |
| documentId | String | Yes |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "delete-document-from-workspace",
"state": "inDev",
"meta": {
"short": "Delete Document From Workspace",
"description": "Deletes a document from a specified workspace in Docusign."
},
"input": [
{
"name": "workspaceId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the workspace from which the document will be deleted."
}
},
{
"name": "documentId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the document to be deleted."
}
}
],
"output": [
{
"name": "success",
"type": "Boolean",
"selector": ["success"],
"meta": {
"description": "Indicates whether the document was successfully deleted."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "DELETE",
"path": "/v2.1/workspaces/{{workspaceId}}/folders/{{folderId}}/files/{{documentId}}",
"headers": {
"Content-Type": "application/json"
}
}
}
]
}
```
The Send Envelope Using Document action initiates a signature request by sending a specified document to designated recipients via Docusign.
{% embed url="" %}
#### Example User Story
I want to send a contract for signature using a prepared document so the recipient can review and sign it quickly.
#### Fields
| Field Name | Field Type | Required |
| -------------- | ---------- | -------- |
| documentId | String | Yes |
| recipientEmail | String | Yes |
| recipientName | String | Yes |
| subject | String | No |
| message | String | No |
| envelopeId | String | No |
| status | String | No |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "send-envelope-using-document",
"state": "inDev",
"meta": {
"short": "Send Envelope Using Document",
"description": "Sends an envelope using a document in Docusign."
},
"input": [
{
"name": "documentId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the document to be sent."
}
},
{
"name": "recipientEmail",
"type": "String",
"required": true,
"meta": {
"description": "The email of the recipient."
}
},
{
"name": "recipientName",
"type": "String",
"required": true,
"meta": {
"description": "The name of the recipient."
}
},
{
"name": "subject",
"type": "String",
"required": false,
"meta": {
"description": "The subject of the envelope."
}
},
{
"name": "message",
"type": "String",
"required": false,
"meta": {
"description": "The message to be included in the envelope."
}
}
],
"output": [
{
"name": "envelopeId",
"type": "String",
"selector": ["envelopeId"],
"meta": {
"description": "The ID of the sent envelope."
}
},
{
"name": "status",
"type": "String",
"selector": ["status"],
"meta": {
"description": "The status of the sent envelope."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v2.1/accounts/{{accountId}}/envelopes",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\n \"emailSubject\": \"{{subject}}\",\n \"documents\": [\n {\n \"documentId\": \"{{documentId}}\",\n \"name\": \"Document\"\n }\n ],\n \"recipients\": {\n \"signers\": [\n {\n \"email\": \"{{recipientEmail}}\",\n \"name\": \"{{recipientName}}\",\n \"recipientId\": \"1\",\n \"routingOrder\": \"1\"\n }\n ]\n },\n \"status\": \"sent\"\n}",
"placeholders": [
{
"name": "accountId",
"type": "String",
"description": "The ID of the Docusign account.",
"required": true
},
{
"name": "accessToken",
"type": "String",
"description": "The access token for Docusign API.",
"required": true
},
{
"name": "documentId",
"type": "String",
"description": "The ID of the document to be sent.",
"required": true
},
{
"name": "recipientEmail",
"type": "String",
"description": "The email of the recipient.",
"required": true
},
{
"name": "recipientName",
"type": "String",
"description": "The name of the recipient.",
"required": true
},
{
"name": "subject",
"type": "String",
"description": "The subject of the envelope.",
"required": false
}
]
}
}
}
]
}
```
The Pause Maestro Workflow Instance action temporarily halts an active workflow to prevent further processing until resumed.
{% embed url="" %}
#### Example User Story
I want to pause a Maestro workflow instance so that I can review and adjust the document before it proceeds to the next step.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| workflowID | String | Yes |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "pause-maestro-workflow-instance",
"state": "inDev",
"meta": {
"short": "Pause Maestro Workflow Instance",
"description": "Pauses an active Maestro workflow instance in Corteza."
},
"input": [
{
"name": "workflowID",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the workflow instance to pause."
}
}
],
"output": [
{
"name": "success",
"type": "Boolean",
"selector": ["success"],
"meta": {
"description": "Indicates whether the workflow instance was successfully paused."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/workflow/instances/{{workflowID}}/pause",
"headers": {
"Content-Type": "application/json"
}
}
}
]
}
```
The Create Draft Signature Request action prepares a signature request as a draft, allowing you to review and edit it before sending.
{% embed url="" %}
#### Example User Story
I want to restore a team member’s access to our DocuSign workspace after their temporary leave, so they can resume managing and reviewing documents.
#### Fields
| Field Name | Field Type | Required |
| ----------- | ---------- | -------- |
| workspaceId | String | Yes |
| userId | String | Yes |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "restore-workspace-user-access",
"state": "inDev",
"meta": {
"short": "Restore Workspace User Access",
"description": "Restores user access to a workspace in Docusign."
},
"input": [
{
"name": "workspaceId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the workspace."
}
},
{
"name": "userId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the user."
}
}
],
"output": [
{
"name": "success",
"type": "Boolean",
"selector": ["success"],
"meta": {
"description": "Indicates whether the operation was successful."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v2.1/workspaces/{{workspaceId}}/users/{{userId}}/restore",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{}"
}
}
}
]
}
```
The Create Signature Request action generates and sends a new envelope for one or more recipients to sign electronically.
{% embed url="" %}
#### Example User Story
I want to create a signature request for a new client contract, so they can review and sign it quickly and securely.
#### Fields
| Field Name | Field Type | Required |
| ------------ | ---------- | -------- |
| emailSubject | String | Yes |
| templateId | String | Yes |
| recipients | Array | Yes |
| status | String | No |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "create-signature-request",
"state": "inDev",
"meta": {
"short": "Create Signature Request",
"description": "Creates a new signature request in Docusign"
},
"input": [
{
"name": "emailSubject",
"type": "String",
"required": true,
"meta": {
"description": "The subject of the email sent to recipients"
}
},
{
"name": "templateId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the template to use for the signature request"
}
},
{
"name": "recipients",
"type": "Array",
"required": true,
"meta": {
"description": "List of recipient emails and roles"
}
},
{
"name": "status",
"type": "String",
"required": false,
"meta": {
"description": "The status of the envelope (e.g., 'sent', 'created')",
"default": "sent"
}
}
],
"output": [
{
"name": "envelopeId",
"type": "String",
"selector": ["envelopeId"],
"meta": {
"description": "The ID of the created envelope"
}
},
{
"name": "status",
"type": "String",
"selector": ["status"],
"meta": {
"description": "The status of the envelope"
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v2.1/accounts/{{accountId}}/envelopes",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"emailSubject\":\"{{emailSubject}}\",\"templateId\":\"{{templateId}}\",\"status\":\"{{status}}\",\"templateRoles\":{{recipients}}}",
"placeholders": [
{
"name": "emailSubject",
"type": "String",
"description": "The subject of the email sent to recipients",
"required": true
},
{
"name": "templateId",
"type": "String",
"description": "The ID of the template to use for the signature request",
"required": true
},
{
"name": "status",
"type": "String",
"description": "The status of the envelope",
"required": false,
"default": "sent"
},
{
"name": "recipients",
"type": "Array",
"description": "List of recipient emails and roles",
"required": true
}
]
}
}
}
]
}
```
The Update Template action modifies an existing template, such as adding fields, changing text, or updating recipient roles.
{% embed url="" %}
#### Example User Story
I want to update our standard NDA template in DocuSign to include a new compliance clause, so all future agreements automatically reflect the latest legal requirements.
#### Fields
| Field Name | Field Type | Required |
| ------------------- | ---------- | -------- |
| templateId | String | Yes |
| templateName | String | No |
| templateDescription | String | No |
| templateRoles | Array | No |
| templateDocuments | Array | No |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "update-template",
"state": "inDev",
"meta": {
"short": "Update Template",
"description": "Updates an existing template in Docusign with the provided details."
},
"input": [
{
"name": "templateId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the template to update."
}
},
{
"name": "templateName",
"type": "String",
"required": false,
"meta": {
"description": "The new name for the template."
}
},
{
"name": "templateDescription",
"type": "String",
"required": false,
"meta": {
"description": "The new description for the template."
}
},
{
"name": "templateRoles",
"type": "Array",
"required": false,
"meta": {
"description": "The new roles for the template."
}
},
{
"name": "templateDocuments",
"type": "Array",
"required": false,
"meta": {
"description": "The new documents for the template."
}
}
],
"output": [
{
"name": "templateId",
"type": "String",
"selector": ["templateId"],
"meta": {
"description": "The ID of the updated template."
}
},
{
"name": "templateName",
"type": "String",
"selector": ["name"],
"meta": {
"description": "The name of the updated template."
}
},
{
"name": "templateUri",
"type": "String",
"selector": ["uri"],
"meta": {
"description": "The URI of the updated template."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "PUT",
"path": "/v2.1/accounts/{{accountId}}/templates/{{templateId}}",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{\"name\": \"{{templateName}}\", \"description\": \"{{templateDescription}}\", \"roles\": {{templateRoles}}, \"documents\": {{templateDocuments}}}",
"placeholders": [
{
"name": "templateName",
"type": "String",
"description": "The new name for the template.",
"required": false
},
{
"name": "templateDescription",
"type": "String",
"description": "The new description for the template.",
"required": false
},
{
"name": "templateRoles",
"type": "Array",
"description": "The new roles for the template.",
"required": false
},
{
"name": "templateDocuments",
"type": "Array",
"description": "The new documents for the template.",
"required": false
}
]
}
}
}
]
}
```
The Void Envelope action cancels a sent envelope, preventing any further signing or access by recipients.
{% embed url="" %}
#### Example User Story
I want to void a DocuSign envelope sent to the wrong client, so I can correct the recipient and resend the document.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| envelopeId | String | Yes |
| voidReason | String | No |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "void-envelope",
"state": "inDev",
"meta": {
"short": "Void Envelope",
"description": "Voids an envelope in DocuSign, making it unavailable for further actions."
},
"input": [
{
"name": "envelopeId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the envelope to void."
}
},
{
"name": "voidReason",
"type": "String",
"required": false,
"meta": {
"description": "The reason for voiding the envelope."
}
}
],
"output": [
{
"name": "success",
"type": "Boolean",
"selector": ["success"],
"meta": {
"description": "Indicates whether the envelope was successfully voided."
}
},
{
"name": "status",
"type": "String",
"selector": ["status"],
"meta": {
"description": "The status of the void operation."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "PUT",
"path": {
"value": "/v2.1/accounts/{{accountId}}/envelopes/{{envelopeId}}",
"placeholders": [
{
"name": "accountId",
"type": "String",
"description": "The DocuSign account ID.",
"required": true
},
{
"name": "envelopeId",
"type": "String",
"description": "The ID of the envelope to void.",
"required": true
}
]
},
"headers": {
"Content-Type": {
"value": "application/json"
}
},
"bodyTemplate": {
"value": "{\"status\": \"voided\", \"voidedReason\": \"{{voidReason}}\"}",
"placeholders": [
{
"name": "voidReason",
"type": "String",
"description": "The reason for voiding the envelope.",
"required": false
}
]
}
}
}
]
}
```
The Create Envelope with Base URL and Account ID Input action generates a new envelope for signing by specifying the DocuSign account and base API URL, allowing customization for different environments or accounts.
{% embed url="" %}
#### Example User Story
I want to create a signature request using our EU DocuSign account’s base URL and account ID, so the envelope is generated in the correct regional environment for compliance.
#### Fields
| Field Name | Field Type | Required |
| ------------------ | ---------- | -------- |
| baseURL | String | Yes |
| accountID | String | Yes |
| envelopeDefinition | String | Yes |
| envelopeID | String | No |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "create-envelope",
"state": "inDev",
"meta": {
"short": "Create Envelope",
"description": "Creates a new envelope in DocuSign with the provided base URL and account ID."
},
"input": [
{
"name": "baseURL",
"type": "String",
"required": true,
"meta": {
"description": "The base URL for the DocuSign API."
}
},
{
"name": "accountID",
"type": "String",
"required": true,
"meta": {
"description": "The account ID for the DocuSign account."
}
},
{
"name": "envelopeDefinition",
"type": "String",
"required": true,
"meta": {
"description": "The envelope definition in JSON format."
}
}
],
"output": [
{
"name": "envelopeID",
"type": "String",
"selector": ["envelopeId"],
"meta": {
"description": "The ID of the created envelope."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "/v2.1/accounts/{{accountID}}/envelopes",
"headers": {
"Content-Type": "application/json"
},
"bodyTemplate": {
"value": "{{envelopeDefinition}}"
}
}
}
]
}
```
The Find Documents List for Envelope query retrieves a list of all documents included in a specific DocuSign envelope.
{% embed url="" %}
#### Example User Story
I want to find the list of documents in a signed DocuSign envelope, so I can verify all required attachments were included before archiving.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| envelopeId | String | Yes |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "find-documents-list-for-envelope",
"state": "inDev",
"meta": {
"short": "Find Documents List for Envelope",
"description": "Retrieves the list of documents associated with a specific envelope in Docusign."
},
"input": [
{
"name": "envelopeId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the envelope for which to retrieve the documents list."
}
}
],
"output": [
{
"name": "documents",
"type": "Array",
"selector": ["documents"],
"meta": {
"description": "List of documents associated with the envelope."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/v2.1/accounts/{{accountId}}/envelopes/{{envelopeId}}/documents",
"headers": {
"Accept": "application/json"
},
"queryParams": {},
"bodyTemplate": {
"value": "",
"placeholders": []
}
}
}
]
}
```
The Find Envelope Info query retrieves detailed information about a specific envelope, such as status, recipients, and timestamps.
{% embed url="" %}
#### Example User Story
I want to find the status and details of a client’s signed contract envelope, so I can confirm it’s fully executed and update our records.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| envelopeId | String | Yes |
| accountId | String | Yes |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "find-envelope-info",
"state": "inDev",
"meta": {
"short": "Find Envelope Info",
"description": "Retrieves information about a specific envelope in DocuSign."
},
"input": [
{
"name": "envelopeId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the envelope to retrieve information for."
}
},
{
"name": "accountId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the DocuSign account."
}
}
],
"output": [
{
"name": "envelopeInfo",
"type": "Object",
"selector": ["envelope"],
"meta": {
"description": "The retrieved envelope information."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/v2.1/accounts/{{accountId}}/envelopes/{{envelopeId}}",
"headers": {
"Accept": "application/json"
}
}
}
]
}
```
The Find Maestro Workflow query searches for and retrieves details about a specific workflow created in DocuSign Maestro.
{% embed url="" %}
#### Example User Story
I want to find the approval workflow for vendor contracts in DocuSign Maestro, so I can review the steps and ensure compliance with our new policy.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| workflowId | String | Yes |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "find-maestro-workflow",
"state": "inDev",
"meta": {
"short": "Find Maestro Workflow",
"description": "Retrieves a specific Maestro workflow from Docusign based on the provided workflow ID."
},
"input": [
{
"name": "workflowId",
"type": "String",
"required": true,
"meta": {
"description": "The unique identifier of the Maestro workflow to retrieve."
}
}
],
"output": [
{
"name": "workflow",
"type": "Object",
"selector": ["workflow"],
"meta": {
"description": "The retrieved Maestro workflow details."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/maestro/workflows/{{workflowId}}",
"headers": {
"Content-Type": "application/json"
}
}
}
]
}
```
The Find Maestro Workflow Instance query retrieves the status and details of a specific running or completed instance of a Maestro workflow.
{% embed url="" %}
#### Example User Story
I want to find the current status of a purchase order approval workflow instance in DocuSign Maestro, so I can follow up with the finance team if it’s delayed.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| workflowID | String | Yes |
| instanceID | String | No |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "find-maestro-workflow-instance",
"state": "inDev",
"meta": {
"short": "Find Maestro Workflow Instance",
"description": "Finds a Maestro workflow instance by ID or other criteria."
},
"input": [
{
"name": "workflowID",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the workflow to find."
}
},
{
"name": "instanceID",
"type": "String",
"required": false,
"meta": {
"description": "The ID of the workflow instance to find."
}
}
],
"output": [
{
"name": "instance",
"type": "Object",
"selector": ["instance"],
"meta": {
"description": "The found workflow instance."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/workflows/{{workflowID}}/instances/{{instanceID}}",
"headers": {}
}
}
]
}
```
The Find Template query searches for and retrieves a specific signing template from your DocuSign account.
{% embed url="" %}
#### Example User Story
I want to find our latest NDA template in DocuSign, so I can use it to quickly send confidential agreements to new partners.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| templateId | String | Yes |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "find-template",
"state": "inDev",
"meta": {
"short": "Find Template",
"description": "Retrieves a specific template from Docusign based on the provided template ID."
},
"input": [
{
"name": "templateId",
"type": "String",
"required": true,
"meta": {
"description": "The unique identifier of the template to retrieve."
}
}
],
"output": [
{
"name": "template",
"type": "Object",
"selector": ["template"],
"meta": {
"description": "The retrieved template object."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/v2.1/accounts/{{accountId}}/templates/{{templateId}}",
"headers": {
"Accept": "application/json"
},
"placeholders": [
{
"name": "accountId",
"type": "String",
"description": "The unique identifier of the Docusign account.",
"required": true
},
{
"name": "templateId",
"type": "String",
"description": "The unique identifier of the template to retrieve.",
"required": true
},
{
"name": "accessToken",
"type": "String",
"description": "The access token for authenticating with Docusign.",
"required": true
}
]
}
}
]
}
```
The Find Workspaces query searches for and lists available workspaces in your DocuSign account.
{% embed url="" %}
#### Example User Story
I want to find all active DocuSign workspaces for my team, so I can organize and assign documents to the correct project folders.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| accountId | String | Yes |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "find-workspaces",
"state": "inDev",
"meta": {
"short": "Find Workspaces",
"description": "Retrieves a list of workspaces from Docusign"
},
"input": [
{
"name": "accountId",
"type": "String",
"required": true,
"meta": {
"description": "The account ID in Docusign"
}
}
],
"output": [
{
"name": "workspaces",
"type": "Array",
"selector": ["workspaces"],
"meta": {
"description": "List of workspaces retrieved from Docusign"
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/v2.1/accounts/{{accountId}}/workspaces",
"headers": {
"Accept": "application/json"
}
}
}
]
}
```
The List Envelopes in Workspace query retrieves a list of envelopes associated with a specific Docusign workspace.
{% embed url="" %}
#### Example User Story
I want to list all envelopes in a workspace so I can quickly review and manage documents awaiting action or completion.
#### Fields
| Field Name | Field Type | Required |
| ----------- | ---------- | -------- |
| workspaceId | String | Yes |
| fromDate | String | No |
| toDate | String | No |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "list-envelopes-in-workspace",
"state": "inDev",
"meta": {
"short": "List Envelopes in Workspace",
"description": "Retrieves a list of envelopes in a specified DocuSign workspace."
},
"input": [
{
"name": "workspaceId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the DocuSign workspace."
}
},
{
"name": "fromDate",
"type": "String",
"required": false,
"meta": {
"description": "The start date for filtering envelopes (ISO 8601 format)."
}
},
{
"name": "toDate",
"type": "String",
"required": false,
"meta": {
"description": "The end date for filtering envelopes (ISO 8601 format)."
}
}
],
"output": [
{
"name": "envelopes",
"type": "Array",
"selector": ["envelopes"],
"meta": {
"description": "List of envelopes in the workspace."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/v2.1/workspaces/{{workspaceId}}/folders",
"headers": {
"Content-Type": "application/json"
},
"queryParams": {
"from_date": "{{fromDate}}",
"to_date": "{{toDate}}"
}
}
}
]
}
```
The Find Form Data for Envelope query extracts all form field data entered by signers in a completed DocuSign envelope.
{% embed url="" %}
#### Example User Story
I want to find all form data from a signed DocuSign contract, so I can automatically update our database with the client’s selected options and details.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| envelopeId | String | Yes |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "find-form-data-for-envelope",
"state": "inDev",
"meta": {
"short": "Find Form Data for Envelope",
"description": "Retrieves form data associated with a specific envelope in DocuSign."
},
"input": [
{
"name": "envelopeId",
"type": "String",
"required": true,
"meta": {
"description": "The unique identifier of the envelope."
}
}
],
"output": [
{
"name": "formData",
"type": "String",
"selector": ["formData"],
"meta": {
"description": "The form data associated with the envelope."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": {
"value": "/v2.1/accounts/{{accountId}}/envelopes/{{envelopeId}}/form_data",
"placeholders": [
{
"name": "accountId",
"type": "String",
"description": "The unique identifier of the DocuSign account.",
"required": true
},
{
"name": "envelopeId",
"type": "String",
"description": "The unique identifier of the envelope.",
"required": true
}
]
},
"headers": {
"Content-Type": {
"value": "application/json"
}
}
}
}
]
}
```
The Find Recipients for Envelope query lists all recipients (signers, cc’d parties, etc.) associated with a specific DocuSign envelope.
{% embed url="" %}
#### Example User Story
I want to find all recipients for a DocuSign envelope, so I can verify who has signed and follow up with those who haven’t.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| envelopeId | String | Yes |
| accountId | String | Yes |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "find-recipients-for-envelope",
"state": "inDev",
"meta": {
"short": "Find Recipients for Envelope",
"description": "Retrieves the list of recipients for a specific envelope in DocuSign."
},
"input": [
{
"name": "envelopeId",
"type": "String",
"required": true,
"meta": {
"description": "The unique identifier of the envelope."
}
},
{
"name": "accountId",
"type": "String",
"required": true,
"meta": {
"description": "The unique identifier of the DocuSign account."
}
}
],
"output": [
{
"name": "recipients",
"type": "Object",
"selector": ["recipients"],
"meta": {
"description": "The list of recipients for the envelope."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/v2.1/accounts/{{accountId}}/envelopes/{{envelopeId}}/recipients",
"headers": {
"Accept": "application/json"
},
"queryParams": {},
"bodyTemplate": {
"value": "",
"placeholders": []
}
}
}
]
}
```
The Find Navigator Agreement query searches for and retrieves a specific agreement or template within DocuSign Navigator.
{% embed url="" %}
#### Example User Story
I want to find our standard service agreement in DocuSign Navigator, so I can quickly send it to new clients for e-signature.
#### Fields
| Field Name | Field Type | Required |
| ----------- | ---------- | -------- |
| agreementId | String | Yes |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "find-navigator-agreement",
"state": "inDev",
"meta": {
"short": "Find Navigator Agreement",
"description": "Retrieves a specific navigator agreement from DocuSign based on the provided agreement ID."
},
"input": [
{
"name": "agreementId",
"type": "String",
"required": true,
"meta": {
"description": "The unique identifier of the navigator agreement to retrieve."
}
}
],
"output": [
{
"name": "agreement",
"type": "Object",
"selector": ["agreement"],
"meta": {
"description": "The retrieved navigator agreement object."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/v2.1/accounts/{{accountId}}/envelopes/{{agreementId}}",
"headers": {
"Accept": "application/json"
}
}
}
]
}
```
The Find Envelope Documents query retrieves all documents associated with a specific Docusign envelope.
{% embed url="" %}
#### Example User Story
I want to find all documents in an envelope so I can review or download the complete set of signed agreements.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| envelopeId | String | Yes |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "find-envelope-documents",
"state": "inDev",
"meta": {
"short": "Find Envelope Documents",
"description": "Retrieves the documents associated with a specific envelope in DocuSign."
},
"input": [
{
"name": "envelopeId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the envelope to retrieve documents from."
}
}
],
"output": [
{
"name": "documents",
"type": "Array",
"selector": ["documents"],
"meta": {
"description": "List of documents associated with the envelope."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/v2.1/envelopes/{{envelopeId}}/documents",
"headers": {
"Accept": "application/json"
}
}
}
]
}
```
The Find Documents in Workspace query searches for and retrieves documents stored in a specified Docusign workspace.
{% embed url="" %}
#### Example User Story
I want to find documents in my workspace so I can locate and manage specific files without scrolling through long lists.
#### Fields
| Field Name | Field Type | Required |
| ----------- | ---------- | -------- |
| workspaceId | String | Yes |
| query | String | No |
| limit | Integer | No |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "find-documents-in-workspace",
"state": "inDev",
"meta": {
"short": "Find Documents in Workspace",
"description": "Search and retrieve documents from a specific workspace in Docusign."
},
"input": [
{
"name": "workspaceId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the workspace to search in."
}
},
{
"name": "query",
"type": "String",
"required": false,
"meta": {
"description": "The search query to filter documents."
}
},
{
"name": "limit",
"type": "Integer",
"required": false,
"meta": {
"description": "Maximum number of documents to return."
}
}
],
"output": [
{
"name": "documents",
"type": "Array",
"selector": ["documents"],
"meta": {
"description": "List of documents found in the workspace."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/v2.1/workspaces/{{workspaceId}}/folders/search",
"queryParams": {
"query": "{{query}}",
"limit": "{{limit}}"
}
}
}
]
}
```
The List Users in Workspace query retrieves a list of all users within a specified DocuSign workspace.
{% embed url="" %}
#### Example User Story
I want to list users in a workspace so I can verify who has access before assigning document permissions.
#### Fields
| Field Name | Field Type | Required |
| ----------- | ---------- | -------- |
| workspaceId | String | Yes |
| accountId | String | Yes |
### Related Connections
[Docusign](/docusign/docusign)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "list-users-in-workspace",
"state": "inDev",
"meta": {
"short": "List Users in Workspace",
"description": "Retrieves a list of users within a specified Docusign workspace."
},
"input": [
{
"name": "workspaceId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the workspace to list users from."
}
},
{
"name": "accountId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the account associated with the workspace."
}
}
],
"output": [
{
"name": "users",
"type": "Array",
"selector": ["users"],
"meta": {
"description": "List of users in the specified workspace."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "GET",
"path": "/v2.1/accounts/{{accountId}}/workspaces/{{workspaceId}}/users",
"headers": {
"Accept": "application/json"
},
"queryParams": {},
"bodyTemplate": {
"value": "",
"placeholders": []
}
}
}
]
}
```
The Create Comment action adds annotated feedback or notes directly on a design file for collaboration.
{% embed url="" %}
#### Example User Story
I want to give quick feedback on the new app button design, so I’ll use Figma’s Create Comment to pin my suggestions directly to the prototype for the team to review.
#### Fields
| Field Name | Field Type | Required |
| ----------- | ---------- | -------- |
| fileKey | String | Yes |
| message | String | Yes |
| nodeId | String | No |
| clientToken | String | Yes |
### Related Connections
[Figma](/figma/figma)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "create-comment",
"state": "inDev",
"meta": {
"short": "Create Comment",
"description": "Creates a new comment on a Figma file or frame."
},
"input": [
{
"name": "fileKey",
"type": "String",
"required": true,
"meta": {
"description": "The key of the Figma file where the comment will be created."
}
},
{
"name": "message",
"type": "String",
"required": true,
"meta": {
"description": "The content of the comment."
}
},
{
"name": "nodeId",
"type": "String",
"required": false,
"meta": {
"description": "The ID of the node (frame, group, etc.) to attach the comment to. If omitted, the comment will be on the entire file."
}
},
{
"name": "clientToken",
"type": "String",
"required": true,
"meta": {
"description": "The client token for authentication with the Figma API."
}
}
],
"output": [
{
"name": "commentId",
"type": "String",
"selector": ["id"],
"meta": {
"description": "The ID of the created comment."
}
},
{
"name": "comment",
"type": "Object",
"selector": [],
"meta": {
"description": "The full comment object returned by the Figma API."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "POST",
"path": "https://api.figma.com/v1/files/{{fileKey}}/comments",
"headers": {
"Content-Type": "application/json",
"X-Figma-Token": "{{clientToken}}"
},
"bodyTemplate": {
"value": "{\"message\": \"{{message}}\", \"node_id\": \"{{nodeId}}\"}",
"placeholders": [
{
"name": "message",
"type": "String",
"description": "The content of the comment.",
"required": true
},
{
"name": "nodeId",
"type": "String",
"description": "The ID of the node to attach the comment to.",
"required": false
}
]
}
}
}
]
}
```
The Delete Comment action removes annotated feedback or notes from a design file to keep discussions clean and relevant.
{% embed url="" %}
#### Example User Story
I want to clean up outdated feedback on our finalized wireframe, so I’ll use Figma’s Delete Comment action to remove resolved notes and keep the file organized.
#### Fields
| Field Name | Field Type | Required |
| ---------- | ---------- | -------- |
| fileKey | String | Yes |
| commentId | String | Yes |
### Related Connections
[Figma](/figma/figma)
### Related Automations
Example link
### Code (Apache v2.0): Operation
```
{
"handle": "delete-comment",
"state": "inDev",
"meta": {
"short": "Delete Comment",
"description": "Deletes a specific comment from a Figma file."
},
"input": [
{
"name": "fileKey",
"type": "String",
"required": true,
"meta": {
"description": "The key of the Figma file containing the comment."
}
},
{
"name": "commentId",
"type": "String",
"required": true,
"meta": {
"description": "The ID of the comment to delete."
}
}
],
"output": [
{
"name": "status",
"type": "String",
"selector": ["status"],
"meta": {
"description": "The status of the deletion operation."
}
}
],
"steps": [
{
"type": "http",
"http": {
"method": "DELETE",
"path": "/v1/files/{{fileKey}}/comments/{{commentId}}",
"headers": {}
}
}
]
}
```
.png?alt=media)
.svg.png?alt=media){kind=logo}
