Create Signature Request from Template with Signaturit API

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

Trigger workflow on

HTTP requests, schedules and app events

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#

Create a workflow to Create Signature Request from Template with the Signaturit API. When you configure and deploy the workflow, it will run on Pipedream's servers 24x7 for free.

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
Select a trigger to run your workflow on HTTP requests, schedules or app events
Deploy the workflow
Send a test event to validate your setup
Turn on the trigger

Integrations#

Create Signature Request from Template with Signaturit API on New Requests (Payload Only) from HTTP / Webhook API

HTTP / Webhook + Signaturit

Try it

Create Signature Request from Template with Signaturit API on New Submission from Typeform API

Typeform + Signaturit

Try it

Create Signature Request from Template with Signaturit API on New Submission (Instant) from Jotform API

Jotform + Signaturit

Try it

Create Signature Request from Template with Signaturit API on New Scheduled Tasks from Pipedream API

Pipedream + Signaturit

Try it

Create Signature Request from Template with Signaturit API on New Download Counts from npm API

npm + Signaturit

Try it

Details#

This is a pre-built, source-available component from Pipedream's GitHub repo. The component is 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.

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

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;
  },
};

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
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" }`

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,