Create Signature Request from Template with Signaturit API on New Folder from Dropbox API

Pipedream makes it easy to connect APIs for Signaturit, Dropbox and 2,900+ other apps remarkably fast.

Trigger workflow on

New Folder from the Dropbox API

Next, do this

Create Signature Request from Template with the Signaturit API

No credit card required

▶

Watch us build a workflow

8 min

Watch now ➜

Trusted by 1,000,000+ developers from startups to Fortune 500 companies

Developers ♥ Pipedream

Getting Started#

This integration creates a workflow with a Dropbox trigger and Signaturit action. When you configure and deploy the workflow, it will run on Pipedream's servers 24x7 for free.

Select this integration
Configure the New Folder trigger
1. Connect your Dropbox account
2. Select a Path
3. Configure Recursive
4. Configure dropboxApphook
Configure the Create Signature Request from Template action
1. Connect your Signaturit account
2. Optional- Configure Body
3. Optional- Select a Branding ID
4. Optional- Configure Callback URL
5. Optional- Configure Custom Data
6. Optional- Select a Delivery Type
7. Optional- Configure Expiration Time (days)
8. Optional- Configure Events URL
9. Optional- Configure Files
10. Configure Name
11. Configure Recipients
12. Optional- Configure CC
13. Optional- Configure Reply To
14. Optional- Configure Reminders (days)
15. Optional- Select a Signing Mode
16. Optional- Configure Subject
17. Select one or more Templates
18. Optional- Select a Type
19. Optional- Configure syncDir
Deploy the workflow
Send a test event to validate your setup
Turn on the trigger

Details#

This integration uses pre-built, source-available components from Pipedream's GitHub repo. These components are developed by Pipedream and the community, and verified and maintained by Pipedream.

To contribute an update to an existing component or create a new component, create a PR on GitHub. If you're new to Pipedream component development, you can start with quickstarts for trigger span and action development, and then review the component API reference.

Trigger#

New Folder on Dropbox

Description:Emit new event when a new folder is created. Make sure the number of files/folders in the watched folder does not exceed 4000.

Version:0.0.19

Key:dropbox-new-folder

View on GitHub

Dropbox Overview#

The Dropbox API on Pipedream enables you to automate file and folder operations, streamlining workflows that involve storing, syncing, and sharing content. With this API, you can programmatically manage files, set up event-driven triggers based on changes within Dropbox, and leverage Pipedream's capabilities to connect with hundreds of other apps for extended automation scenarios. It's ideal for building custom file management solutions, archiving systems, or collaborative content workflows without writing extensive code.

Trigger Code#

import common from "../common/common.mjs";
import sampleEmit from "./test-event.mjs";

export default {
  ...common,
  dedupe: "unique",
  type: "source",
  key: "dropbox-new-folder",
  name: "New Folder",
  version: "0.0.19",
  description: "Emit new event when a new folder is created. Make sure the number of files/folders in the watched folder does not exceed 4000.",
  hooks: {
    async activate() {
      await this.getHistoricalEvents([
        "folder",
      ]);
      const state = await this.dropbox.initState(this);
      this._setDropboxState(state);
    },
  },
  async run() {
    const state = this._getDropboxState();
    const {
      ret: updates, state: newState,
    } = await this.dropbox.getUpdates(this, state);
    this._setDropboxState(newState);
    for (const update of updates) {
      if (update[".tag"] !== "folder") {
        continue;
      }
      this.$emit(update, this.getMeta(update.id, update.path_display || update.id));
    }
  },
  sampleEmit,
};

Trigger Configuration#

This component may be configured based on the props defined in the component code. Pipedream automatically prompts for input values in the UI and CLI.

Label	Prop	Type	Description
Dropbox	`dropbox`	`app`	This component uses the Dropbox app.
N/A	`db`	`$.service.db`	This component uses `$.service.db` to maintain state between executions.
Path	`path`	`string`	Select a value from the drop down menu.
Recursive	`recursive`	`boolean`	Also watch sub-directories and their contents.
	`dropboxApphook`	`$.interface.apphook`

Trigger Authentication#

Dropbox uses OAuth authentication. When you connect your Dropbox account, Pipedream will open a popup window where you can sign into Dropbox and grant Pipedream permission to connect to your account. Pipedream securely stores and automatically refreshes the OAuth tokens so you can easily authenticate any Dropbox API.

Pipedream requests the following authorization scopes when you connect your account:

About Dropbox#

Dropbox gives you secure access to all your files. Collaborate with friends, family, and coworkers from any device.

Action#

Create Signature Request from Template on Signaturit

Description:Creates a signature request using a pre-existing template. [See the documentation](https://docs.signaturit.com/api/latest#signatures_create_signature)

Version:0.1.2

Key:signaturit-create-signature-request-from-template

View on GitHub

Signaturit Overview#

The Signaturit API enables automated document signing, tracking, and management directly within Pipedream. By integrating this API, users can create workflows to send documents for signature, check the status of sent documents, and receive updates when documents are signed or declined, all from a serverless platform. By leveraging Pipedream's capacity for integrating various APIs and services, users can seamlessly include e-signature capabilities into their business processes without manual intervention.

Action Code#

import FormData from "form-data";
import { getFileStreamAndMetadata } from "@pipedream/platform";
import {
  DELIVERY_TYPE_OPTIONS,
  SIGNATURE_TYPE_OPTIONS,
  SIGNING_MODE_OPTIONS,
} from "../../common/constants.mjs";
import { parseObject } from "../../common/utils.mjs";
import signaturit from "../../signaturit.app.mjs";

export default {
  key: "signaturit-create-signature-request-from-template",
  name: "Create Signature Request from Template",
  description: "Creates a signature request using a pre-existing template. [See the documentation](https://docs.signaturit.com/api/latest#signatures_create_signature)",
  version: "0.1.2",
  annotations: {
    destructiveHint: false,
    openWorldHint: true,
    readOnlyHint: false,
  },
  type: "action",
  props: {
    signaturit,
    body: {
      propDefinition: [
        signaturit,
        "body",
      ],
      description: "Email body (html code is allowed) for **email** and **sms** type requests. Note: For **sms** request types it will be truncated to 120 characters Note: For **sms** the body should contain the tag **{{url}}** where we will include the document url.",
      optional: true,
    },
    brandingId: {
      propDefinition: [
        signaturit,
        "brandingId",
      ],
      optional: true,
    },
    callbackUrl: {
      type: "string",
      label: "Callback URL",
      description: "Url to redirect the user when finish the signature process.",
      optional: true,
    },
    data: {
      propDefinition: [
        signaturit,
        "data",
      ],
      optional: true,
    },
    deliveryType: {
      type: "string",
      label: "Delivery Type",
      description: "Delivery type for signature request.",
      options: DELIVERY_TYPE_OPTIONS,
      optional: true,
    },
    expireTime: {
      type: "integer",
      label: "Expiration Time (days)",
      description: "Expiration time of the document in days (max 365).",
      min: 1,
      max: 365,
      optional: true,
    },
    eventsUrl: {
      propDefinition: [
        signaturit,
        "eventsUrl",
      ],
      optional: true,
    },
    files: {
      propDefinition: [
        signaturit,
        "attachments",
      ],
      label: "Files",
      optional: true,
    },
    name: {
      type: "string",
      label: "Name",
      description: "Name assigned to the signature request.",
    },
    recipients: {
      propDefinition: [
        signaturit,
        "recipients",
      ],
      description: "List of recipients in JSON format, e.g., '{\"name\": \"John Doe\", \"email\": \"john@example.com\", \"phone\": \"34555667788\"}'. [See the documentation](https://docs.signaturit.com/api/latest#signatures_create_signature) for further information.",
    },
    cc: {
      type: "string[]",
      label: "CC",
      description: "List with email recipients containing name and email for people that will receive a copy of the signed document when the process is completed. e.g., '{\"name\": \"John Doe\", \"email\": \"john@example.com\"}'.",
      optional: true,
    },
    replyTo: {
      type: "string",
      label: "Reply To",
      description: "Email Reply-To address.",
      optional: true,
    },
    reminders: {
      type: "string[]",
      label: "Reminders (days)",
      description: "Reminders in days to send automatic reminders. You can set it 0 to disable reminders. E.g. [1,3,4]",
      optional: true,
    },
    signingMode: {
      type: "string",
      label: "Signing Mode",
      description: "The signing mode lets you control the order in which your recipients receive and sign your documents.",
      options: SIGNING_MODE_OPTIONS,
      optional: true,
    },
    subject: {
      propDefinition: [
        signaturit,
        "subject",
      ],
      optional: true,
    },
    templates: {
      propDefinition: [
        signaturit,
        "templates",
      ],
    },
    type: {
      type: "string",
      label: "Type",
      description: "The type of the signature.",
      options: SIGNATURE_TYPE_OPTIONS,
      optional: true,
    },
    syncDir: {
      type: "dir",
      accessMode: "read",
      sync: true,
      optional: true,
    },
  },
  methods: {
    transformArray({
      arr, prefixBase, formData,
    }) {
      let result = [];
      function processObject(obj, prefix = "") {
        for (let key in obj) {
          if (Array.isArray(obj[key])) {
            obj[key].forEach((item, index) => {
              processObject(item, `${prefix}[${key}][${index}]`);
            });
          } else if (typeof obj[key] === "object") {
            processObject(obj[key], `${prefix}[${key}]`);
          } else {
            result.push({
              key: `${prefixBase}${prefix}[${key}]`,
              value: `${obj[key]}`,
            });
          }
        }
      }
      arr.map((item, index) => {
        processObject(item, `[${index}]`);
      });
      for (const {
        key, value,
      } of result) {
        formData.append(key, value);
      }
      return result;
    },
  },
  async run({ $ }) {
    const formData = new FormData();
    this.transformArray({
      arr: parseObject(this.recipients),
      prefixBase: "recipients",
      formData,
    });
    if (this.cc) {
      let j = 0;
      for (const item of parseObject(this.cc)) {
        formData.append(`cc[${j++}]`, item);
      }
    }
    if (this.data) {
      for (const [
        key,
        value,
      ] of Object.entries(parseObject(this.data))) {
        formData.append(`data[${key}]`, value);
      }
    }
    if (this.templates) {
      let k = 0;
      for (const templateId of parseObject(this.templates)) {
        formData.append(`templates[${k++}]`, templateId);
      }
    }
    if (this.reminders) {
      let m = 0;
      for (const reminder of parseObject(this.reminders)) {
        formData.append(`reminders[${m++}]`, reminder);
      }
    }
    if (this.body) formData.append("body", this.body);
    if (this.brandingId) formData.append("branding_id", this.brandingId);
    if (this.callbackUrl) formData.append("callback_url", this.callbackUrl);
    if (this.deliveryType) formData.append("delivery_type", this.deliveryType);
    if (this.expireTime) formData.append("expire_time", this.expireTime);
    if (this.eventsUrl) formData.append("events_url", this.eventsUrl);
    if (this.name) formData.append("name", this.name);
    if (this.replyTo) formData.append("reply_to", this.replyTo);
    if (this.type) formData.append("type", this.type);

    if (this.files) {
      let k = 0;
      for (const file of parseObject(this.files)) {
        const {
          stream, metadata,
        } = await getFileStreamAndMetadata(file);
        formData.append(`files[${k++}]`, stream, {
          contentType: metadata.contentType,
          knownLength: metadata.size,
          filename: metadata.name,
        });
      }
    }
    const response = await this.signaturit.createSignatureRequest({
      $,
      data: formData,
      headers: formData.getHeaders(),
    });
    $.export("$summary", `Created signature request with ID: ${response.id}`);
    return response;
  },
};

Action Configuration#

This component may be configured based on the props defined in the component code. Pipedream automatically prompts for input values in the UI.

Label	Prop	Type	Description
Signaturit	`signaturit`	`app`	This component uses the Signaturit app.
Body	`body`	`string`	Email body (html code is allowed) for email and sms type requests. Note: For sms request types it will be truncated to 120 characters Note: For sms the body should contain the tag {{url}} where we will include the document url.
Branding ID	`brandingId`	`string`	Select a value from the drop down menu.
Callback URL	`callbackUrl`	`string`	Url to redirect the user when finish the signature process.
Custom Data	`data`	`object`	Custom key-value data in JSON format.
Delivery Type	`deliveryType`	`string`	Select a value from the drop down menu:`{ "label": "Email - The signature request is sent by email. This is the default behavior when no type is specified.", "value": "email" }{ "label": "SMS - The signature request is sent by SMS. You must include the phone in the recipients parameter.", "value": "sms" }{ "label": "URL - The signature request is not sent to the signer. Instead of this, the creation request will return a url parameter that you can open in the browser to complete the signature.", "value": "url" }`
Expiration Time (days)	`expireTime`	`integer`	Expiration time of the document in days (max 365).
Events URL	`eventsUrl`	`string`	URL to receive real-time events.
Files	`files`	`string[]`	The file(s) to attach. For each entry, provide either a file URL or a path to a file in the `/tmp` directory (for example, `/tmp/myFile.txt`)
Name	`name`	`string`	Name assigned to the signature request.
Recipients	`recipients`	`string[]`	List of recipients in JSON format, e.g., '{"name": "John Doe", "email": "john@example.com", "phone": "34555667788"}'. See the documentation for further information.
CC	`cc`	`string[]`	List with email recipients containing name and email for people that will receive a copy of the signed document when the process is completed. e.g., '{"name": "John Doe", "email": "john@example.com"}'.
Reply To	`replyTo`	`string`	Email Reply-To address.
Reminders (days)	`reminders`	`string[]`	Reminders in days to send automatic reminders. You can set it 0 to disable reminders. E.g. [1,3,4]
Signing Mode	`signingMode`	`string`	Select a value from the drop down menu:`{ "label": "Sequential - Each recipient receives the request once the previous recipient has completed their action.", "value": "sequential" }{ "label": "Parallel - All recipients receive the request in parallel.", "value": "parallel" }`
Subject	`subject`	`string`	Email subject for email type requests.
Templates	`templates`	`string[]`	Select a value from the drop down menu.
Type	`type`	`string`	Select a value from the drop down menu:`{ "label": "Simple - A simple signature request is created.", "value": "simple" }{ "label": "Advanced - An advanced signature request is created. We capture the biometric information of the signer with the signature draw.", "value": "advanced" }{ "label": "Smart - The system creates different type of signature depending in the user device. A simple signature is created for desktop pcs and advanced signature is created for mobile and tablet devices.", "value": "smart" }`
syncDir	`syncDir`	`dir`

Action Authentication#

Signaturit uses API keys for authentication. When you connect your Signaturit account, Pipedream securely stores the keys so you can easily authenticate to Signaturit APIs in both code and no-code steps.

To retrieve your Acccess Token,

Navigate to your Signaturit account and sign in
Click the User dropdown on the top right
Go to “My account” > “Integrations”

About Signaturit#

Leading European provider of digital signature, digital transaction management and trust services.

More Ways to Connect Signaturit + Dropbox#

Other Popular Integrations#

Create Certified Email with Signaturit API on New or Modified File or Folder from Dropbox API

Dropbox + Signaturit

Try it

Create Certified Email with Signaturit API on New File from Dropbox API

Dropbox + Signaturit

Try it

Create Certified Email with Signaturit API on New Folder from Dropbox API

Dropbox + Signaturit

Try it

Send Signature Request Reminder with Signaturit API on New or Modified File or Folder from Dropbox API

Dropbox + Signaturit

Try it

Send Signature Request Reminder with Signaturit API on New File from Dropbox API

Dropbox + Signaturit

Try it

Popular Triggers#

New File from the Dropbox API

Emit new event when a new file is added to your account or a specific folder. Make sure the number of files/folders in the watched folder does not exceed 4000.

Try it

New Folder from the Dropbox API

Emit new event when a new folder is created. Make sure the number of files/folders in the watched folder does not exceed 4000.

Try it

New or Modified File or Folder from the Dropbox API

Emit new event when a file or folder is added or modified. Make sure the number of files/folders in the watched folder does not exceed 4000.

Try it

New Signed Document from the Signaturit API

Emit new event when a document has been newly signed.

Try it