Create Signature Request from Template with Signaturit API on Custom Interval from Schedule API

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

Trigger workflow on

Custom Interval from the Schedule 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 Schedule 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 Custom Interval trigger
1. Connect your Schedule account
2. Configure Cron Schedule
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
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#

Custom Interval on Schedule

Description:Trigger your workflow every N hours, minutes or seconds.

Version:0.0.2

Key:schedule-custom-interval

View on GitHub

Schedule Overview#

The Schedule app in Pipedream is a powerful tool that allows you to trigger workflows at regular intervals, ranging from every minute to once a year. This enables the automation of repetitive tasks and the scheduling of actions to occur without manual intervention. By leveraging this API, you can execute code, run integrations, and process data on a reliable schedule, all within Pipedream's serverless environment.

Trigger Code#

import schedule from "../../schedule.app.mjs";

export default {
  name: "Custom Interval",
  version: "0.0.2",
  key: "schedule-custom-interval",
  type: "source",
  description: "Trigger your workflow every N hours, minutes or seconds.",
  props: {
    schedule,
    cron: {
      propDefinition: [
        schedule,
        "cron",
      ],
    },
  },
};

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
Schedule	`schedule`	`app`	This component uses the Schedule app.
Cron Schedule	`cron`	`$.interface.timer`	Enter a cron expression

Trigger Authentication#

The Schedule API does not require authentication.

About Schedule#

Trigger workflows on an interval or cron schedule.

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.0.1

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 fs from "fs";
import {
  DELIVERY_TYPE_OPTIONS,
  SIGNATURE_TYPE_OPTIONS,
  SIGNING_MODE_OPTIONS,
} from "../../common/constants.mjs";
import {
  checkTmp,
  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.0.1",
  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,
    },
  },
  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)) {
        formData.append(`files[${k++}]`, fs.createReadStream(checkTmp(file)));
      }
    }
    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[]`	A list of paths to the files saved to the `/tmp` directory (e.g. `/tmp/example.pdf`). See the documentation.
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" }`

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,