Create Signature Request from Template with Signaturit API on New Item in Feed from RSS API

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

Trigger workflow on

New Item in Feed from the RSS 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 RSS 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 Item in Feed trigger
1. Connect your RSS account
2. Configure timer
3. Configure Feed URL
4. Configure Published After
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#

New Item in Feed on RSS

Description:Emit new items from an RSS feed

Version:1.2.7

Key:rss-new-item-in-feed

View on GitHub

RSS Overview#

The RSS app allows users to automatically fetch and parse updates from web feeds. This functionality is pivotal for staying abreast of content changes or updates from websites, blogs, and news outlets that offer RSS feeds. With Pipedream, you can harness the RSS API to trigger workflows that enable a broad range of automations, like content aggregation, monitoring for specific keywords, notifications, and data synchronization across platforms.

Trigger Code#

import { defineSource } from "@pipedream/types";
import rss from "../../app/rss.app.mjs";
import rssCommon from "../common/common.mjs";
export default defineSource({
    ...rssCommon,
    key: "rss-new-item-in-feed",
    name: "New Item in Feed",
    description: "Emit new items from an RSS feed",
    version: "1.2.7",
    type: "source",
    dedupe: "unique",
    props: {
        ...rssCommon.props,
        url: {
            propDefinition: [
                rss,
                "url",
            ],
        },
        publishedAfter: {
            type: "string",
            label: "Published After",
            description: "Emit items published after the specified date in ISO 8601 format .e.g `2022-12-07T12:57:10+07:00`",
            default: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(), // default to one day ago
        },
    },
    hooks: {
        async activate() {
            // Try to parse the feed one time to confirm we can fetch and parse.
            // The code will throw any errors to the user.
            await this.rss.fetchAndParseFeed(this.url);
        },
    },
    methods: {
        ...rssCommon.methods,
        generateMeta: function (item) {
            return {
                id: this.rss.itemKey(item),
                summary: item.title,
                ts: Date.now(),
            };
        },
    },
    async run() {
        const items = await this.rss.fetchAndParseFeed(this.url);
        for (const item of items.reverse()) {
            const publishedAfter = +new Date(this.publishedAfter);
            const ts = this.rss.itemTs(item);
            if (Number.isNaN(publishedAfter) || publishedAfter > ts) {
                continue;
            }
            const meta = this.generateMeta(item);
            this.$emit(item, meta);
        }
    },
});

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
RSS	`rss`	`app`	This component uses the RSS app.
	`timer`	`$.interface.timer`	How often you want to poll the feed for new items
Feed URL	`url`	`string`	Enter the URL for any public RSS feed
Published After	`publishedAfter`	`string`	Emit items published after the specified date in ISO 8601 format .e.g `2022-12-07T12:57:10+07:00`

Trigger Authentication#

The RSS API does not require authentication.

About RSS#

Real Simple Syndication

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,