# About @Human by Planet Crust
Open-source sovereign AI enterprise system for building, integrating and migrating enterprise applications with multi-agent automation.
### What is @Human?
#### @Human is the Sovereign AI Enterprise System.
Multi-Agentic AI infrastructure, AI Automation and 100% open-source, @Human increases productivity while driving traditional software and SaaS costs down. Leverage the benefits of AI and stay in control.
#### @Human has 4 primary characteristics:
Cover image
Comprehensive and Safer AI Enablement
@Human Agents provide an Agentforce alternative for delivering and managing multi-agentic deployments.
@Human Connections and @Human Automations provide a Zapier alternative to integrating with third-party cloud and software providers.
Build light-weight or full enterprise applications for adding, storing, visualizing and processing data.
The @Human Treaty Compliance Layer (TCL) governance feature is embedded in the @Human Agent configuration console that automatically cross-references every agent's description, system prompt, and guardrails against a curated library of binding international laws, human rights treaties, and regulations.
Comprehensive Salesforce Alternative features to design, develop and deploy Customer Resource Management (CRM), Case Management, Service Management Logistics, ERP and other enterprise systems.
Leverage mature, standardised components, deployed globally by Fortune 100 businesses such as Cisco and KBR, government institutions and thousands of enterprises.
Replicate and move safely from proprietary solutions such as Salesforce, Zoho, Dynamics and others.
Work with your staff, partners and AI on @Human Teams, our collaboration platform designed to align humans and LLMs (Large Language Models) to optimal effect.
Deploy AI Assistants tailored to individual needs and which measurably improve the performance of your staff and improve productivity.
Use @Human Namespaces to build Applications to cater for any enterprise system use case.
Administer and secure @Human with enterprise-grade tools.
After you receive your email with the URL, browse to your instance:
Click on "Create a new account"
Once you've signed up, you will be take directly to the Home page of @Human. The first user to login is always the Super-Admin. For security purposes, subsequent users that sign-up will be allocated the "Authenticated" role by default - this is a role with basic system permission.
Enter the "Admin Area" via the left menu bar
Click on "LLM Providers" (7th item from the top on left menu bar)
Select "+ New LLM Provider". This lets you choose which AI you wish to use. The defaults are Mistral or Anthropic (Claude), but you may also add others.
Add an LLM Name (can be the same as the provider or not), select your LLM and add your API key
Once setup, you should see the following confirmation in the list of LLM providers:
The essentials are now in place to start building your first AI Agents.
# Creating your First Agent
### Introduction
@Human has a vast range of enterprise system builder features. However, simply put, the goal is to use the AI Suite and Application Suite to create AI services and applications for your End-users.
You may choose to give your End-users AI superpowers at the heart of a rich ecosystem of third-party software providers, or, you may decide to allocate them a basic role on a single @Human application. Such choices represent the extraordinary opportunity of AI. @Human endeavours to make them manageable, safer and sovereign.
As a super-administrator, you may create as many @Human Agents, Automations and Namespaces (where applications live in @Human) as you wish. The only limit is the compute and storage available to you.
### Create your first Agent
{% embed url="" %}
### Adding your Agent to Sidebar Assistant
All @Human instances have a Sidebar AI Assistant. To display your Agent in the Sidebar, scroll to the bottom left of the Agent Configuration and add the roles for which the Agent should be seen.
Save your Agent, then click on the icon in the top right corner of your screen. The Assistant Sidebar will open and your Agent will be available to use in the dropdown menu at the top of the Sidebar.
### Displaying your Agent in @Human Home
Any Agent that displays in the Assistant Sidebar also displays be default in the Agent interface in @Human Home i.e. the configuration is the same for both
# @Human Home
The "Home" page in @Human is where you land immediately after login.
For Super-Administrators (by default the first person to login), Home consists of three primary sections:
1. Applications is where @Human's key resources are accessed.
The platform "Admin Area", "Namespaces" for new application creation and management), the "TAQ" (Trigger/Action/Query) Automation Engine for integrating with third party Connections and Agentic processes, the "Agentic" management engine for creating and managing agents and, lastly, the "Projects" area for organising and attributing various components with labels.
What Applications a user sees depends on their Role in the @Human platform.
2. Multi-Agentic conversation interface.
When you leave Home, this UI is available on right side-bar by clicking on the AI (:sparkles:) button in the top right corner.
By default, the conversation interface is set to the Super-Administrator Agent, which has access to many of the systems resources. To enable this Agent, you will need to
* Setup an LLM provider in the Admin Area. Mistral is supported by default, but other LLM providers should work too (as long as they provide an API)
* Set the Super-Administrator Agent to "Active" in the Agentic configuration
* Attribute the LLM provider and model to the Super-Administrator Agent in the Agentic configuration
You can have multiple chats with any individual Agent by clicking on the "+" sign. Furthermore, you may toggle between different Agents (after you have configured them, of course), by clicking on the drop-down beside the title of the Agent.
What Agents a user sees depends entirely on the Role you give them in the @Human platform.
3. Notifications
Notifications are usually configured with a TAQ Automation and can be both general or linked to a record in a Namespace application. If they are linked to a record, then clicking on the Notification will navigate you to the record in question.
# Docs Link
Explains how Docs Link buttons in the @Human Platform open the relevant @Human Docs page for each feature.
Almost every page in the @Human Platform has a button on the right hand side of the top bar:
This button serves to take the user directly to the relevant page in the [@Human Docs](https://docs.planetcrust.com/) documentation site.
Most buttons will lead to unique feature explainer pages, but some will lead to shared pages, in particular if a feature needs little explanation.
# Roadmap
### Create Your First Agent
{% embed url="" %}
### Add a Treaty Compliance Layer (TCL)
The [Treaty Compliance Layer (TCL)](/human-agents/treaty-compliance-layer-tcl) adds essential international compliance regulations to your @Human Agent.
{% embed url="" %}
### Create your first Namespace Application ("Email2")
[Namespaces](/human-namespaces) are where applications are built in @Human. You can create as many as you like.
Here we build a simple email list application which we will later integrate with an Automation and an Agent (see below)
{% embed url="" %}
### Build an Agent to Generate Email Addresses
This agent generates email addresses which will be used by a TAQ Automation (below) to populate the Email2 Namespace Application (above).
{% embed url="" %}
### Build your First TAQ Automation
This TAQ (Trigger/Action/Query) Automation uses the Email Generation Agent above to create an email address, then stores this email address to the Email2 Namespace Application (2 steps above)
{% embed url="" %}
### Enabling the Sidebar Assistant
Depending on their role, any user can have access to multiple @Human Agents
{% embed url="" %}
# Salesforce Alternative CRM
### Salesforce Standard Objects
This @Human CRM uses Salesforce Standard Objects to underpin its data model. The vast majority of such [Standard Objects](https://developer.salesforce.com/docs/atlas.en-us.object_reference.meta/object_reference/sforce_api_objects_list.htm) can be created/replicated in @Human.
### Headless
Data Models in @Human are API-First by design. Any Namespace Application, Module or Field can be reached via API. No additional fees, API tariffs or any such commercial usage tax.
### Basic Overview
This model shows a high-level view of the components that go into building a Salesforce CRM Alternative. It also highlights ease with which the system can be created.
{% embed url="" %}
# What is @Human Agentic?
Open-Source Agentforce Alternative
{% hint style="success" %}
Looking to build your first agent? Jump to the [About](/creating-your-first-agent) section!
{% endhint %}
### Agentforce Alternative
Seamlessly integrated with Corteza Low-Code (the open-source Salesforce alternative), @Human Agentic is a multi-agent framework delivered in 100% open-source code (Apache v2.0 license).
### No Limits, No Lock-in
@Human Agentic is intended to drive the costs of using AI down as far as possible. There are no limits on users, agent count, automations, third-party connections or applications
### AI Safety to the Forefront
LLM AI technology is extraordinary, but the models' fundamental architectures usually depend on probability. @Human has many features which foster greater AI safety and outcomes.
@Human is not an LLM (Large Language Model e.g. Mistral, Claude, OpenAI) itself, but rather a layer which sits above or in front of your choice of LLM provider. From this perspective, it can be viewed as a set of meaningful, if ever evolving, constraints on LLM behaviour.
For more information, please see the following sections on [AI Safety](/human-agents/ai-safety) and the [Treaty Compliance Layer (TCL)](/human-agents/treaty-compliance-layer-tcl).
# AI Safety
### Safety by Design
@Human Agentic comes with a significant list of safety features. These are likely to evolve as AI technology evolves and will always remain a top priority for Planet Crust.
### Essential Features
#### Active/Inactive Setting
All Agents can be easily switched on or off
#### Model Choice
LLM Provider and Model choice is exclusively set by the Administrator
#### Temperature
The randomness "Temperature" of any Agents can be set individually
#### Budget Controls
Token count and iterations can be controlled on a per Agent basis
#### Timeouts
Excessive looping and other expensive runtime errors can be mitigated
#### Behavioral Guardrails
An unlimited number of guardrails can be specified per Agent
#### Internal Knowledge Base
Dedicated internal knowledge bases can be used to guide Agentic behaviour
#### MCP Policy
An MCP Policy enforces local data access
... and access to Automation tools
#### RBAC Integration
Agentic access can be integrated with the @Human RBAC system
# Treaty Compliance Layer (TCL)
***
The @Human Treaty Compliance Layer is a governance feature built directly into the @Human Agent configuration console. When an administrator - human or AI - creates an @Human Agent by entering a description, a system prompt, and a set of behavioural guardrails, those three components are automatically and instantly cross-referenced against a structured library of binding international laws, human rights treaties, and regional regulations.
The compliance library that underpins the layer covers the full spectrum of legal instruments governing AI systems that interact with people. It includes the General Data Protection Regulation (GDPR), the EU AI Act, the Council of Europe Framework Convention on Artificial Intelligence (CETS 225) - the world's first binding international AI treaty - the EU Charter of Fundamental Rights, the European Convention on Human Rights, the UNESCO Recommendation on the Ethics of Artificial Intelligence, the UN Guiding Principles on Business and Human Rights, and the core ILO labour conventions. Each instrument is represented at the article and clause level, with precise descriptions and canonical interpretation references, so that the cross-referencing process is legally specific rather than generically aspirational.
# Legislation
### **GDPR - General Data Protection Regulation (EU 2016/679)**
The GDPR is the European Union's foundational data protection law, in force since May 2018, and the most operationally significant instrument governing any AI system that processes personal data. It establishes six core principles (lawfulness, fairness, transparency, purpose limitation, data minimisation, accuracy, storage limitation and accountability) and grants individuals enforceable rights including the right to erasure, the right to data portability and, crucially for AI agents, the right under Article 22 not to be subject to decisions based solely on automated processing that produce legal or similarly significant effects. This last right is the direct legal basis for mandatory human-in-the-loop pathways in any @Human Agent whose outputs can materially affect a natural person.
### **EU AI Act - Regulation (EU) 2024/1689**
The EU AI Act, which entered into force in August 2024, is the world's first comprehensive legal framework specifically regulating artificial intelligence systems, applying to any AI whose outputs are used within the European Union regardless of where the provider is based. It establishes a four-tier risk classification - unacceptable, high, limited, and minimal - and imposes graduated obligations accordingly, with Article 5 setting out a list of absolute prohibitions including emotion recognition in workplaces, social scoring, subliminal manipulation, biometric categorisation to infer sensitive characteristics, and real-time remote biometric identification; Article 14 mandating meaningful human oversight for high-risk systems; and Article 50 requiring that users be informed when they are interacting with an AI system, making it the primary legal source for the behavioural constraints in @Human Agents.
### **CETS 225 - Council of Europe Framework Convention on AI (2024)**
Adopted on 17 May 2024 and opened for signature on 5 September 2024, CETS 225 is the world's first binding international treaty on artificial intelligence, signed by the European Union, the United States, the United Kingdom, Canada, Australia, Japan, Israel, and Mexico, and applying to AI systems throughout their entire lifecycle — from design and development through deployment and decommissioning. It requires that all AI activities be consistent with human rights obligations, human dignity, non-discrimination, transparency, accountability, and the rule of law; it introduces explicit obligations around equality and non-discrimination (Article 10), human oversight and the right to meaningful intervention (Article 11), and accountability for adverse impacts (Article 9), making it the broadest international legal anchor for the @Human Treaty Compliance Layer and the instrument that extends its obligations beyond the EU to all signatory states.
### **EU Charter of Fundamental Rights**
The EU Charter, which has the same legal force as the EU Treaties themselves, enshrines the fundamental rights of all persons in the European Union and binds all EU institutions and member states whenever they act within the scope of EU law. For AI agents, its most relevant provisions are Article 7 (respect for private and family life), Article 8 (the right to protection of personal data, which has constitutional rather than merely regulatory status), Article 20 (equality before the law), Article 21 (non-discrimination on grounds including sex, race, ethnicity, religion, disability, age, and sexual orientation), and Article 47 (the right to an effective remedy and a fair trial), which together establish the constitutional foundation for data protection, non-discriminatory agent behaviour and the contestability of automated decisions.
### **ECHR - European Convention on Human Rights (ETS No. 005)**
The ECHR is the foundational human rights treaty of the Council of Europe, binding on all 46 member states and enforced by the European Court of Human Rights, whose judgments have directly shaped the law on workplace surveillance and data privacy. For AI agents, Article 8 - the right to respect for private and family life - is the most consequential provision; it has been interpreted by the Court in landmark workplace surveillance cases including Barbulescu v. Romania (2017) and López Ribalda v. Spain (2019) to impose strict proportionality requirements on employer monitoring, directly informing the constraints on worker-monitoring agents in @Human, while Article 10 (freedom of expression) and Article 11 (freedom of assembly and association, including trade union rights) provide the basis for prohibitions on content-suppression and union-activity tracking by agents.
### **UNESCO Recommendation on the Ethics of Artificial Intelligence (2021)**
Adopted unanimously by all 193 UNESCO member states in November 2021, this is the first global instrument on AI ethics to be endorsed at intergovernmental level. While it is a recommendation rather than a binding treaty, its endorsement by every UN member state gives it substantial normative authority as the global ethical consensus on AI. It establishes eleven core principles - including proportionality and do no harm, safety and security, fairness and non-discrimination, privacy and data protection, human oversight and determination, transparency and explainability, responsibility and accountability, and environmental sustainability. Its proportionality principle requires that in cases of irreversible or life-altering decisions humans must retain the final say.
### **UN Guiding Principles on Business and Human Rights (UNGPs, 2011)**
Endorsed by the UN Human Rights Council in June 2011, the UNGPs establish the global standard for corporate responsibility to respect human rights. It is organised around three pillars: the state duty to protect human rights, the corporate responsibility to respect them through Human Rights Due Diligence (HRDD), and access to remedy for affected individuals. The UN Working Group on Business and Human Rights has explicitly applied the UNGPs to AI procurement and deployment, meaning that any enterprise deploying AI agents - including @Human - carries HRDD obligations to identify, prevent, mitigate, and account for adverse human rights impacts.
### **ILO Core Labour Conventions - C87, C98, C111, C190 & MNE Declaration**
The International Labour Organisation's core conventions represent the global floor of workers' rights, binding on the 187 ILO member states that have ratified them and forming part of the ILO Declaration on Fundamental Principles and Rights at Work. Convention C87 (1948) protects freedom of association and the right to organise; C98 (1949) protects the right to collective bargaining; C111 (1958) prohibits discrimination in employment and occupation on grounds including sex, race, colour, religion, political opinion, national extraction, and social origin; C190 (2019) protects workers from violence and harassment; and the ILO's Multinational Enterprises Declaration extends these obligations to supply chain HRDD - together forming the legal basis for @Human's prohibitions on monitoring union activity, algorithmic discrimination in recruitment and evaluation, and abusive surveillance of workers, as well as for the mandatory bias audits required before any employment-context agent is deployed.
# Multi-Agent, Multi-Chat
### Multi-Chat
All @Human Agents facilitate multiple simultaneous chats with a user
#### Multi-Agent
Any user may have several Agents available to them simultaneously and toggle between them at will.
# Integration with TAQ Automations
### Introduction
[TAQ (Trigger/Action/Query) Automations](/human-automations) are designed to integrate directly and safely with @Human Agentic. They also act as a fulcrum between @Human Agentic and [@Human Connections](/human-connections).
Integration between Agentic and TAQ Automations is two-way:
* An Agent may invoke one or more TAQ Automations ("TAQ")
* A TAQ may invoke one or more @Human Agents
### Agentic Invocation of TAQ
Any Agent can be permitted to invoke a TAQ by clicking on the "Allowed TAQs" dropdown menu in the Agent configuration panel.
The permitted TAQ will then be added to the MCP (Model Context Protocol) Policy for the Agent in question.
On the TAQ side of the equation, the Trigger type should be set to "Agent Invoked" and the nature of the Agentic output to be received (usually a text string) should be defined in the parameters of the TAQ Trigger.
### TAQ Invocation of Agents
An independently triggered TAQ Automation can invoke one or more Agents.
The Agent can also hand output back to the TAQ and the conversation can be continued.
### Different Agents - Different Models?
You may find it useful to select different LLM models depending on the Agent's purpose. For more programmatic or simple actions, a cheaper LLM model will usually suffice.
However, for more nuanced communication (e.g. replying to customer enquiry), it makes sense to use more advanced models. In the diagram above, different Agents could employ different LLM models without impacting the design of the TAQ.
# Integration with @Human Connections
### TAQ as an Integration Fulcrum
@Human Agents will not have direct access to third-party API's. For safety reasons, this will be achieved by the Agent invoking a TAQ automation, which in turn will have access to a permitted list of API Connections.
@Human Connections will be available by 30 April 2026
# @Human Automations
### What are @Human TAQ Automations?
TAQ stands for Triggers/Actions/Queries. The TAQ Automation Engine is a Zapier-like tool for creating "If-This-Then-That" type process logic.
The @Human TAQ Automation Engine (we often refer to it just as "TAQ" - pronounced like Thumb "Tack") runs above the @Human Workflows execution engine. In some respects, it is a vastly simplified version of @Human Workflows, designed to be used by non-engineers. More importantly, it is designed to be used easily and safely with AI Agents.
# Creating a New TAQ Automation
### Navigate to Automations
If you're in @Human Home then this is found on the left menu bar...
If you are anywhere else in the platform, then this is found on the right menu bar, which can be opened by clicking on the four small squares in the top corner of your screen.
The TAQ Automation menu contains a list of all TAQs in the platform, indicating whether they are "Active" or "Inactive". You may filter the TAQs by name.
Click on to open the "Create new TAQ" modal
Add a TAQ Name, then click on "Create" to be taken to the TAQ canvas
# TAQ Triggers
### Creating Triggers
The first block on any TAQ Canvas will be the "Add Trigger" block
Clicking on "Add Trigger" will open a modal from which you can select a Trigger type
### Trigger Types
There are 4 key types of TAQ Triggers. They are mostly self-explanatory.
* System Triggers include Manual (i.e. button on a Namespace application), Interval (e.g. every 24 hours) and Timestamp (e.g. DD-MM-YYYY)
* Record Triggers involve triggering a TAQ before and after Namespace application records are created, updated or deleted (e.g. after a lead is created in the @Human CRM, the user will receive a notification)
* User Triggers involve triggering a TAQ after users are created, updated, suspended or deleted (e.g. when a user is created, send them a welcome notification)
* Agent Invoke Triggers are used when a TAQ needs to receive the output of an Agent as its triggering input. The Agent Invoke Trigger enables safe handover between the Agent and the TAQ.
* Connection Triggers refer to trigger events from third party connections (e.g. when a new branch is created in Github, update the engineering events record).
### System Triggers
#### Manual Trigger
The Manual Trigger is the simplest to configure in the TAQ itself.
To use a Manual Trigger in a Namespace application, you will need to add an [Automation block](#user-content-fn-1)[^1] in a Page Builder.
The button can be added to any page and sized or coloured as required
#### Interval Trigger
As the name suggests, you may choose an interval from the dropdown list. The TAQ will run each time this interval occurs
#### Timestamp Trigger
Pick a specific date and time at which you require your TAQ to run
### Record Triggers
#### After Record Create
This Trigger is one of the most popular. You need to enter both the Namespace application and the specific Module in which the Record will be created. The TAQ will start each time a record is created in this module (e.g. a new lead has been created in the Lead Module of the CRM Namespace, then prompt an agent to write a welcome email and send it the following morning at 9am)
#### After Record Delete
You need to enter both the Namespace application and the specific Module in which the Record will be created. The TAQ will start each time a record is created in this module.
#### After Record Undelete
Records at the Namespace application layer are only "soft" deleted in @Human (Hard delete is done at the database layer). This can be a useful feature e.g. if records need to be recovered in order to continue process.
#### After Record Update
Changes to records can often be used to trigger process e.g. a change in an employee's status might imply the need to have new system roles.
#### Before Record Create
This is a particularly useful Trigger for cross-checks e.g. verifying that an account does not already exist before you create a new one.
#### Before Record Delete
This Trigger is useful for cross-checks before removing a record e.g. are there any related outstanding actions, such as support requests, required for an account before the record is deleted.
#### Before Record Undelete
Can be useful in scenarios where undeletion is subject to a policy check or in scenarios where duplication checking might be necessary.
#### Before Record Update
Excellent for checking whether changes have already been applied or for creating conditional logic based on an existing record state.
### Agent Invoked Trigger
The Agent Invoked Trigger is specifically for use when an @Human Agent needs to invoke a TAQ and pass a value to it.
The type of value expected is usually a text string, but it can also be a number or a boolean/checkbox (e.g. when the Agent needs to confirm a decision).
The TAQ to be used by the Agent is selected within the Agent Configuration interface.
[^1]: Add link
# TAQ Actions and Queries (Lookups)
### Types of Actions and Lookups
The Actions and Lookups in TAQ Automations fall broadly into five categories:
* Creation of Notifications
* Lookup, Create, Update and Delete of Records
* Create, Update and Delete of Users
* Agent Prompting
* Third-party Actions and Lookups. These are not documented here, but in [@Human Connections](/human-connections).
### Notifications
#### Send Notification
This is the simpler of the two TAQ notification actions, producing a non-linked notification
The Notification itself shows directly in the notification sidebar. The number on the alarm bell in the top right corner will increase to indicated a notification. Clicking on the alarm bell opens the notification side bar.
### Records
#### Clone Record
Creates a copy of an existing record
#### Create Record
Creates a record in a specific Namespace Module, allowing a value to specified manually or inherited from a previous step (e.g. the output of an Agent).
#### Delete Record
Deletes a record by its value/ID
#### Find Newest Record
Finds the latest record in a specified Namespace Module
#### Find Oldest Record
Finds the first record created in a specified Namespace Module
#### Update Record
Updates and existing record with one or more specified values.
# @Human Connections
Overview of the @Human Connections ecosystem
### 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](/human-connections/asana/asana/action-create-a-project)
[Action: Update a Project](/human-connections/asana/asana/action-update-a-project)
[Action: Create a Task](/human-connections/asana/asana/action-create-a-task)
[Action: Update a Task](/human-connections/asana/asana/action-update-a-task)
#### Query Operations
[Query: Get a Project](/human-connections/asana/asana/query-get-a-project)
[Query: Get a Task](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/canva/canva/action-upload-asset)
[Action: Autofill Design From Brand Template](/human-connections/canva/canva/action-autofill-design-from-brand-template)
[Action: Import Design](/human-connections/canva/canva/action-import-design)
[Action: API Request](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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](/human-connections/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": []
}
}
}
]
}
```