New Message Received from Sendblue API

Pipedream makes it easy to connect APIs for Sendblue and 3,000+ other apps remarkably fast.

Trigger workflow on

New Message Received from the Sendblue API

Next, do this

Connect to 3,000+ APIs using code and no-code building blocks

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#

Trigger a workflow on New Message Received with Sendblue API. When you configure and deploy the workflow, it will run on Pipedream's servers 24x7 for free.

Configure the New Message Received trigger
1. Connect your Sendblue account
2. Configure timer
3. Optional- Configure Account Email
4. Optional- Configure From Number
5. Optional- Configure To Number
6. Optional- Configure Group ID
7. Optional- Select a Message Type
8. Optional- Select a Service Type
9. Optional- Select a Status
10. Optional- Select a Order By
11. Optional- Select a Order Direction
12. Optional- Configure Limit
Add steps to connect to 3,000+ APIs using code and no-code building blocks
Deploy the workflow
Send a test event to validate your setup
Turn on the trigger

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.

New Message Received on Sendblue

Description:Emit new event when a new inbound message is received. [See the documentation](https://docs.sendblue.com/api/resources/messages/methods/list)

Version:0.0.1

Key:sendblue-new-message-received

View on GitHub

Code#

import { DEFAULT_POLLING_SOURCE_TIMER_INTERVAL } from "@pipedream/platform";
import app from "../../sendblue.app.mjs";

export default {
  key: "sendblue-new-message-received",
  name: "New Message Received",
  description: "Emit new event when a new inbound message is received. [See the documentation](https://docs.sendblue.com/api/resources/messages/methods/list)",
  version: "0.0.1",
  type: "source",
  dedupe: "unique",
  props: {
    app,
    db: "$.service.db",
    timer: {
      type: "$.interface.timer",
      default: {
        intervalSeconds: DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
      },
    },
    accountEmail: {
      propDefinition: [
        app,
        "accountEmail",
      ],
    },
    fromNumberFilter: {
      propDefinition: [
        app,
        "fromNumberFilter",
      ],
    },
    toNumberFilter: {
      propDefinition: [
        app,
        "toNumberFilter",
      ],
    },
    groupIdFilter: {
      propDefinition: [
        app,
        "groupIdFilter",
      ],
    },
    messageTypeFilter: {
      propDefinition: [
        app,
        "messageTypeFilter",
      ],
    },
    serviceFilter: {
      propDefinition: [
        app,
        "serviceFilter",
      ],
    },
    statusFilter: {
      propDefinition: [
        app,
        "statusFilter",
      ],
    },
    orderBy: {
      propDefinition: [
        app,
        "orderBy",
      ],
    },
    orderDirection: {
      propDefinition: [
        app,
        "orderDirection",
      ],
    },
    limit: {
      propDefinition: [
        app,
        "limit",
      ],
    },
  },
  hooks: {
    async deploy() {
      await this.processEvent(25);
      this._setIsFirstRun(false);
    },
  },
  methods: {
    _getLastTimestamp() {
      return this.db.get("lastTimestamp") || 0;
    },
    _setLastTimestamp(timestamp) {
      this.db.set("lastTimestamp", timestamp);
    },
    _getIsFirstRun() {
      return this.db.get("isFirstRun") !== false;
    },
    _setIsFirstRun(value) {
      this.db.set("isFirstRun", value);
    },
    async processEvent(max) {
      const lastTimestamp = this._getLastTimestamp();

      // Build query params from user-selected filters
      const params = {
        is_outbound: false,
        limit: this.limit || 50,
      };

      if (this.accountEmail) {
        params.account_email = this.accountEmail;
      }

      if (this.fromNumberFilter) {
        params.from_number = this.fromNumberFilter;
      }

      if (this.toNumberFilter) {
        params.to_number = this.toNumberFilter;
      }

      if (this.groupIdFilter) {
        params.group_id = this.groupIdFilter;
      }

      if (this.messageTypeFilter) {
        params.message_type = this.messageTypeFilter;
      }

      if (this.serviceFilter) {
        params.service = this.serviceFilter;
      }

      if (this.statusFilter) {
        params.status = this.statusFilter;
      }

      if (this.orderBy) {
        params.order_by = this.orderBy;
      }

      if (this.orderDirection) {
        params.order_direction = this.orderDirection;
      }

      const response = await this.app.listMessages({
        params,
      });

      const messages = response.data || [];

      if (!messages.length) {
        return;
      }

      // Filter for messages newer than the last timestamp
      // Use date_updated as the reliable timestamp field
      const newMessages = messages.filter((message) => {
        const dateToUse = message.date_updated || message.date_sent;
        const messageTime = new Date(dateToUse).getTime();
        return messageTime > lastTimestamp;
      }).slice(0, max);

      if (newMessages.length > 0) {
        // Update the last timestamp to the most recent message
        const mostRecentTime = Math.max(...newMessages.map((m) => {
          const dateToUse = m.date_updated || m.date_sent;
          return new Date(dateToUse).getTime();
        }));
        this._setLastTimestamp(mostRecentTime);
      }

      newMessages.forEach((message) => {
        const meta = this.generateMeta(message);
        this.$emit(message, meta);
      });
    },
    generateMeta(message) {
      const dateToUse = message.date_updated || message.date_sent;
      return {
        id: message.message_handle,
        summary: `New message from ${message.from_number}`,
        ts: new Date(dateToUse).getTime(),
      };
    },
  },
  async run() {
    // Skip first run since deploy hook already executed processEvent
    if (this._getIsFirstRun()) {
      this._setIsFirstRun(false);
      return;
    }
    await this.processEvent();
  },
};

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
Sendblue	`app`	`app`	This component uses the Sendblue app.
N/A	`db`	`$.service.db`	This component uses `$.service.db` to maintain state between executions.
	`timer`	`$.interface.timer`
Account Email	`accountEmail`	`string`	Filter by account email
From Number	`fromNumberFilter`	`string`	Filter by sender phone number
To Number	`toNumberFilter`	`string`	Filter by recipient phone number
Group ID	`groupIdFilter`	`string`	Filter by group ID
Message Type	`messageTypeFilter`	`string`	Select a value from the drop down menu:`{ "label": "Direct Message", "value": "message" }{ "label": "Group Message", "value": "group" }`
Service Type	`serviceFilter`	`string`	Select a value from the drop down menu:`{ "label": "iMessage", "value": "iMessage" }{ "label": "SMS", "value": "SMS" }`
Status	`statusFilter`	`string`	Select a value from the drop down menu:`REGISTEREDPENDINGSENTDELIVEREDRECEIVEDQUEUEDERRORDECLINEDACCEPTEDSUCCESS`
Order By	`orderBy`	`string`	Select a value from the drop down menu:`{ "label": "Created At", "value": "createdAt" }{ "label": "Updated At", "value": "updatedAt" }{ "label": "Sent At", "value": "sentAt" }`
Order Direction	`orderDirection`	`string`	Select a value from the drop down menu:`{ "label": "Ascending", "value": "asc" }{ "label": "Descending", "value": "desc" }`
Limit	`limit`	`integer`	Maximum number of messages to return (1-1000)