@pipedream/linkupapi 0.0.1 → 0.2.0

package/actions/connect-to-profile/connect-to-profile.mjs

@@ -0,0 +1,65 @@
+import app from "../../linkupapi.app.mjs";
+
+export default {
+  type: "action",
+  key: "linkupapi-connect-to-profile",
+  name: "Connect to Profile",
+  description: "Send a connection request to a LinkedIn profile. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/Network/connect)",
+  version: "0.0.2",
+  props: {
+    app,
+    linkedinUrl: {
+      propDefinition: [
+        app,
+        "linkedinUrl",
+      ],
+    },
+    loginToken: {
+      propDefinition: [
+        app,
+        "loginToken",
+      ],
+    },
+    message: {
+      type: "string",
+      label: "Message",
+      description: "Optional custom message to include with connection request",
+      optional: true,
+    },
+    country: {
+      propDefinition: [
+        app,
+        "country",
+      ],
+    },
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    openWorldHint: true,
+    idempotentHint: false,
+  },
+  async run({ $ }) {
+    const {
+      app,
+      linkedinUrl,
+      loginToken,
+      message,
+      country,
+    } = this;
+
+    const response = await app.connectToProfile({
+      $,
+      data: {
+        linkedin_url: linkedinUrl,
+        login_token: loginToken,
+        message_text: message,
+        country,
+      },
+    });
+
+    $.export("$summary", "Successfully sent connection request");
+
+    return response;
+  },
+};

package/actions/create-comment/create-comment.mjs

@@ -0,0 +1,61 @@
+import linkupapi from "../../linkupapi.app.mjs";
+
+export default {
+  key: "linkupapi-create-comment",
+  name: "Create Comment",
+  description: "Create a comment on a post. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/posts/comment)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: false,
+  },
+  props: {
+    linkupapi,
+    postUrl: {
+      type: "string",
+      label: "Post URL",
+      description: "LinkedIn post URL to comment on (must contain a valid activity URN)",
+    },
+    message: {
+      type: "string",
+      label: "Message",
+      description: "Text content of the comment to post",
+    },
+    loginToken: {
+      propDefinition: [
+        linkupapi,
+        "loginToken",
+      ],
+    },
+    country: {
+      propDefinition: [
+        linkupapi,
+        "country",
+      ],
+    },
+    companyUrl: {
+      propDefinition: [
+        linkupapi,
+        "companyUrl",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.linkupapi.createComment({
+      $,
+      data: {
+        post_url: this.postUrl,
+        message: this.message,
+        login_token: this.loginToken,
+        country: this.country,
+        company_url: this.companyUrl,
+      },
+    });
+
+    $.export("$summary", "Successfully created comment");
+
+    return response;
+  },
+};

package/actions/get-company-info/get-company-info.mjs

@@ -0,0 +1,56 @@
+import app from "../../linkupapi.app.mjs";
+
+export default {
+  type: "action",
+  key: "linkupapi-get-company-info",
+  name: "Get Company Info",
+  description: "Extract detailed information about a company from LinkedIn. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/Companies/company-info)",
+  version: "0.0.2",
+  props: {
+    app,
+    companyUrl: {
+      type: "string",
+      label: "Company URL",
+      description: "LinkedIn company URLs. Eg. `https://www.linkedin.com/company/stripe/`",
+      optional: true,
+    },
+    loginToken: {
+      propDefinition: [
+        app,
+        "loginToken",
+      ],
+    },
+    country: {
+      propDefinition: [
+        app,
+        "country",
+      ],
+    },
+  },
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true,
+    idempotentHint: true,
+  },
+  async run({ $ }) {
+    const {
+      app,
+      companyUrl,
+      loginToken,
+      country,
+    } = this;
+
+    const response = await app.getCompanyInfo({
+      $,
+      data: {
+        company_url: companyUrl,
+        login_token: loginToken,
+        country,
+      },
+    });
+
+    $.export("$summary", "Successfully retrieved company information");
+    return response;
+  },
+};

package/actions/get-conversation-messages/get-conversation-messages.mjs

@@ -0,0 +1,83 @@
+import { ConfigurationError } from "@pipedream/platform";
+import app from "../../linkupapi.app.mjs";
+
+export default {
+  type: "action",
+  key: "linkupapi-get-conversation-messages",
+  name: "Get Conversation Messages",
+  description: "Retrieve messages from a LinkedIn conversation. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/Messages/conversation)",
+  version: "0.0.2",
+  props: {
+    app,
+    loginToken: {
+      propDefinition: [
+        app,
+        "loginToken",
+      ],
+    },
+    linkedinUrl: {
+      propDefinition: [
+        app,
+        "linkedinUrl",
+      ],
+      optional: true,
+      description: "LinkedIn URL of the other party (required if **Conversation ID** is not provided)",
+    },
+    conversationId: {
+      propDefinition: [
+        app,
+        "conversationId",
+        ({ loginToken }) => ({
+          loginToken,
+        }),
+      ],
+      optional: true,
+      description: "LinkedIn conversation ID (required if **LinkedIn URL** is not provided)",
+    },
+    totalResults: {
+      type: "integer",
+      label: "Total Results",
+      description: "Number of messages to retrieve when not in pagination mode (default: 10)",
+      optional: true,
+    },
+    country: {
+      propDefinition: [
+        app,
+        "country",
+      ],
+    },
+  },
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true,
+    idempotentHint: true,
+  },
+  async run({ $ }) {
+    const {
+      loginToken,
+      linkedinUrl,
+      conversationId,
+      totalResults,
+      country,
+    } = this;
+
+    if (!linkedinUrl && !conversationId) {
+      throw new ConfigurationError("Either **LinkedIn URL** or **Conversation ID** is required");
+    }
+
+    const response = await this.app.getConversationMessages({
+      $,
+      data: {
+        login_token: loginToken,
+        linkedin_url: linkedinUrl,
+        conversation_id: conversationId,
+        country,
+        total_results: totalResults,
+      },
+    });
+
+    $.export("$summary", "Successfully retrieved conversation messages");
+    return response;
+  },
+};

package/actions/get-invitations-status/get-invitations-status.mjs

@@ -0,0 +1,57 @@
+import app from "../../linkupapi.app.mjs";
+
+export default {
+  type: "action",
+  key: "linkupapi-get-invitations-status",
+  name: "Get Invitations Status",
+  description: "Check the status of connection invitations for a LinkedIn profile. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/Network/get_invitations_status)",
+  version: "0.0.2",
+  props: {
+    app,
+    linkedinUrl: {
+      propDefinition: [
+        app,
+        "linkedinUrl",
+      ],
+    },
+    loginToken: {
+      propDefinition: [
+        app,
+        "loginToken",
+      ],
+    },
+    country: {
+      propDefinition: [
+        app,
+        "country",
+      ],
+    },
+  },
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true,
+    idempotentHint: true,
+  },
+  async run({ $ }) {
+    const {
+      app,
+      linkedinUrl,
+      loginToken,
+      country,
+    } = this;
+
+    const response = await app.getInvitationsStatus({
+      $,
+      data: {
+        linkedin_url: linkedinUrl,
+        login_token: loginToken,
+        country,
+      },
+    });
+
+    $.export("$summary", "Successfully retrieved invitation status");
+
+    return response;
+  },
+};

package/actions/get-profile-info/get-profile-info.mjs

@@ -0,0 +1,57 @@
+import app from "../../linkupapi.app.mjs";
+
+export default {
+  type: "action",
+  key: "linkupapi-get-profile-info",
+  name: "Get Profile Info",
+  description: "Extract information from a LinkedIn profile. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/Profile/profile-info)",
+  version: "0.0.2",
+  props: {
+    app,
+    linkedinUrl: {
+      propDefinition: [
+        app,
+        "linkedinUrl",
+      ],
+    },
+    loginToken: {
+      propDefinition: [
+        app,
+        "loginToken",
+      ],
+    },
+    country: {
+      propDefinition: [
+        app,
+        "country",
+      ],
+    },
+  },
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true,
+    idempotentHint: true,
+  },
+  async run({ $ }) {
+    const {
+      app,
+      linkedinUrl,
+      loginToken,
+      country,
+    } = this;
+
+    const response = await app.getProfileInfo({
+      $,
+      data: {
+        linkedin_url: linkedinUrl,
+        login_token: loginToken,
+        country,
+      },
+    });
+
+    $.export("$summary", "Successfully retrieved profile information");
+
+    return response;
+  },
+};

package/actions/login/login.mjs

@@ -0,0 +1,56 @@
+import app from "../../linkupapi.app.mjs";
+
+export default {
+  type: "action",
+  key: "linkupapi-login",
+  name: "Login",
+  description: "Authenticate with LinkedIn credentials. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/authentication/login)",
+  version: "0.0.2",
+  props: {
+    app,
+    email: {
+      propDefinition: [
+        app,
+        "email",
+      ],
+    },
+    password: {
+      propDefinition: [
+        app,
+        "password",
+      ],
+    },
+    country: {
+      propDefinition: [
+        app,
+        "country",
+      ],
+    },
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    openWorldHint: true,
+  },
+  async run({ $ }) {
+    const {
+      app,
+      email,
+      password,
+      country,
+    } = this;
+
+    const response = await app.login({
+      $,
+      data: {
+        email,
+        password,
+        country,
+      },
+    });
+
+    $.export("$summary", "Successfully authenticated with LinkedIn account");
+
+    return response;
+  },
+};

package/actions/search-companies/search-companies.mjs

@@ -0,0 +1,99 @@
+import app from "../../linkupapi.app.mjs";
+import utils from "../../common/utils.mjs";
+
+export default {
+  type: "action",
+  key: "linkupapi-search-companies",
+  name: "Search Companies",
+  description: "Search for companies on LinkedIn based on criteria. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/Companies/search)",
+  version: "0.0.2",
+  props: {
+    app,
+    loginToken: {
+      propDefinition: [
+        app,
+        "loginToken",
+      ],
+    },
+    keyword: {
+      type: "string",
+      label: "Keyword",
+      description: "Search keyword for company filtering",
+      optional: true,
+    },
+    location: {
+      description: "Geographic locations to filter companies",
+      propDefinition: [
+        app,
+        "location",
+      ],
+    },
+    sector: {
+      type: "string[]",
+      label: "Sector",
+      description: "Industry sector you can [find the label here](https://learn.microsoft.com/en-us/linkedin/shared/references/reference-tables/industry-codes-v2)",
+      optional: true,
+    },
+    companySize: {
+      type: "string",
+      label: "Company Size",
+      description: "Employee count range: 1-10 employees 11-50 employees 51-200 employees 201-500 employees 501-1000 employees 1001-5000 employees 5001-10000 employees 10001+ employees",
+      optional: true,
+      options: [
+        "1-10",
+        "11-50",
+        "51-200",
+        "201-500",
+        "501-1000",
+        "1001-5000",
+        "5001-10000",
+        "10001+",
+      ],
+    },
+    totalResults: {
+      type: "integer",
+      label: "Total Results",
+      description: "Number of companies to retrieve when not in pagination mode (default: 10)",
+      optional: true,
+    },
+    country: {
+      propDefinition: [
+        app,
+        "country",
+      ],
+    },
+  },
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true,
+    idempotentHint: true,
+  },
+  async run({ $ }) {
+    const {
+      loginToken,
+      country,
+      keyword,
+      location,
+      sector,
+      companySize,
+      totalResults,
+    } = this;
+
+    const response = await this.app.searchCompanies({
+      $,
+      data: {
+        login_token: loginToken,
+        country,
+        keyword,
+        location: utils.getOptionalProp(location),
+        sector: utils.getOptionalProp(sector),
+        company_size: companySize,
+        total_results: totalResults,
+      },
+    });
+
+    $.export("$summary", "Successfully retrieved companies");
+    return response;
+  },
+};

package/actions/search-profiles/search-profiles.mjs

@@ -0,0 +1,144 @@
+import app from "../../linkupapi.app.mjs";
+import utils from "../../common/utils.mjs";
+
+export default {
+  type: "action",
+  key: "linkupapi-search-profiles",
+  name: "Search Profiles",
+  description: "Search for LinkedIn profiles based on criteria. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/Profile/search)",
+  version: "0.0.2",
+  props: {
+    app,
+    loginToken: {
+      propDefinition: [
+        app,
+        "loginToken",
+      ],
+    },
+    keyword: {
+      type: "string",
+      label: "Keyword",
+      description: "Search keyword to find relevant profiles",
+      optional: true,
+    },
+    firstName: {
+      type: "string",
+      label: "First Name",
+      description: "First name parameter for advanced keyword search",
+      optional: true,
+    },
+    lastName: {
+      type: "string",
+      label: "Last Name",
+      description: "Last name parameter for advanced keyword search",
+      optional: true,
+    },
+    title: {
+      type: "string",
+      label: "Job Title",
+      description: "Job title parameter for advanced keyword search",
+      optional: true,
+    },
+    companyUrl: {
+      propDefinition: [
+        app,
+        "companyUrl",
+      ],
+    },
+    location: {
+      description: "Geographic locations to filter profiles",
+      propDefinition: [
+        app,
+        "location",
+      ],
+    },
+    schoolUrl: {
+      type: "string[]",
+      label: "School URLs",
+      description: "LinkedIn school URLs",
+      optional: true,
+    },
+    network: {
+      type: "string[]",
+      label: "Network Connection Level",
+      description: "Filter by connection level",
+      options: [
+        {
+          value: "F",
+          label: "First-degree connections (1st)",
+        },
+        {
+          value: "S",
+          label: "Second-degree connections (2nd)",
+        },
+        {
+          value: "O",
+          label: "Out-of-network connections (3rd+)",
+        },
+      ],
+      optional: true,
+    },
+    totalResults: {
+      type: "integer",
+      label: "Total Results",
+      description: "Number of profiles to retrieve (default: `10`)",
+      optional: true,
+    },
+    fetchInvitationState: {
+      type: "boolean",
+      label: "Fetch Invitation State",
+      description: "Whether to fetch the invitation/connection status for each profile",
+      optional: true,
+    },
+    country: {
+      propDefinition: [
+        app,
+        "country",
+      ],
+    },
+  },
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true,
+    idempotentHint: true,
+  },
+  async run({ $ }) {
+    const {
+      app,
+      loginToken,
+      country,
+      keyword,
+      firstName,
+      lastName,
+      title,
+      companyUrl,
+      location,
+      schoolUrl,
+      network,
+      totalResults,
+      fetchInvitationState,
+    } = this;
+
+    const response = await app.searchProfiles({
+      $,
+      data: {
+        login_token: loginToken,
+        country,
+        keyword,
+        first_name: firstName,
+        last_name: lastName,
+        title,
+        company_url: utils.getOptionalProp(companyUrl),
+        location: utils.getOptionalProp(location),
+        school_url: utils.getOptionalProp(schoolUrl),
+        network: utils.getOptionalProp(network, ","),
+        fetch_invitation_state: fetchInvitationState,
+        total_results: totalResults,
+      },
+    });
+
+    $.export("$summary", "Successfully retrieved profiles");
+    return response;
+  },
+};

package/actions/send-message/send-message.mjs

@@ -0,0 +1,78 @@
+import app from "../../linkupapi.app.mjs";
+
+export default {
+  type: "action",
+  key: "linkupapi-send-message",
+  name: "Send Message",
+  description: "Send a message to a LinkedIn profile. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/Messages/send)",
+  version: "0.0.2",
+  props: {
+    app,
+    // eslint-disable-next-line pipedream/props-label, pipedream/props-description
+    info: {
+      type: "alert",
+      alertType: "info",
+      content: "Make sure you previously connected to the LinkedIn profile you want to send a message to.",
+    },
+    loginToken: {
+      propDefinition: [
+        app,
+        "loginToken",
+      ],
+    },
+    linkedinUrl: {
+      propDefinition: [
+        app,
+        "linkedinUrl",
+      ],
+    },
+    messageText: {
+      propDefinition: [
+        app,
+        "messageText",
+      ],
+    },
+    country: {
+      propDefinition: [
+        app,
+        "country",
+      ],
+    },
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    openWorldHint: true,
+    idempotentHint: false,
+  },
+  async run({ $ }) {
+    const {
+      app,
+      linkedinUrl,
+      messageText,
+      loginToken,
+      country,
+    } = this;
+
+    try {
+      const response = await app.sendMessage({
+        $,
+        data: {
+          linkedin_url: linkedinUrl,
+          message_text: messageText,
+          login_token: loginToken,
+          country,
+        },
+      });
+
+      $.export("$summary", "Successfully sent message request");
+
+      return response;
+    } catch (error) {
+      if (error.response?.data?.data === "Invalid parameter") {
+        throw new Error("Invalid parameter. Make sure you previously connected to the LinkedIn profile you want to send a message to.");
+      }
+      throw error;
+    }
+  },
+};

package/actions/verify-code/verify-code.mjs

@@ -0,0 +1,57 @@
+import app from "../../linkupapi.app.mjs";
+
+export default {
+  type: "action",
+  key: "linkupapi-verify-code",
+  name: "Verify Code",
+  description: "Verify security code for LinkedIn authentication. [See the documentation](https://docs.linkupapi.com/api-reference/linkup/authentication/verify)",
+  version: "0.0.2",
+  props: {
+    app,
+    email: {
+      propDefinition: [
+        app,
+        "email",
+      ],
+    },
+    code: {
+      propDefinition: [
+        app,
+        "code",
+      ],
+    },
+    country: {
+      propDefinition: [
+        app,
+        "country",
+      ],
+    },
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    openWorldHint: true,
+    idempotentHint: false,
+  },
+  async run({ $ }) {
+    const {
+      app,
+      email,
+      code,
+      country,
+    } = this;
+
+    const response = await app.verify({
+      $,
+      data: {
+        email,
+        code,
+        country,
+      },
+    });
+
+    $.export("$summary", "Successfully verified code for email");
+
+    return response;
+  },
+};

package/common/utils.mjs

@@ -0,0 +1,9 @@
+function getOptionalProp(value, separator = ";") {
+  return Array.isArray(value) && value.length > 0
+    ? value.join(separator)
+    : undefined;
+}
+
+export default {
+  getOptionalProp,
+};

package/linkupapi.app.mjs

@@ -1,11 +1,205 @@
+import { axios } from "@pipedream/platform";
+
 export default {
   type: "app",
   app: "linkupapi",
-  propDefinitions: {},
+  propDefinitions: {
+    email: {
+      type: "string",
+      label: "Email",
+      description: "Email address for LinkedIn account",
+    },
+    password: {
+      type: "string",
+      label: "Password",
+      description: "Password for LinkedIn account",
+      secret: true,
+    },
+    country: {
+      type: "string",
+      label: "Country",
+      description: "Country code for proxy selection",
+      optional: true,
+      options: [
+        "US",
+        "UK",
+        "FR",
+        "DE",
+        "NL",
+        "IT",
+        "IL",
+        "CA",
+        "BR",
+        "ES",
+        "IN",
+      ],
+    },
+    loginToken: {
+      type: "string",
+      label: "Login Token",
+      description: "LinkedIn authentication token obtained from login/verify process",
+      secret: true,
+    },
+    code: {
+      type: "string",
+      label: "Verification Code",
+      description: "Verification code received via email",
+    },
+    linkedinUrl: {
+      type: "string",
+      label: "LinkedIn URL",
+      description: "LinkedIn profile or company URL. Eg. `https://www.linkedin.com/in/john-doe/` or `https://www.linkedin.com/company/stripe/`",
+    },
+    conversationId: {
+      type: "string",
+      label: "Conversation ID",
+      description: "LinkedIn conversation identifier",
+      async options({
+        prevContext, loginToken,
+      }) {
+        if (!loginToken || prevContext?.nextCursor === null) {
+          return [];
+        }
+        const {
+          data: {
+            conversations,
+            next_cursor,
+          },
+        } = await this.getConversations({
+          data: {
+            login_token: loginToken,
+            next_cursor: prevContext?.nextCursor,
+          },
+        });
+        return {
+          options: conversations.map(({
+            conversation_id: value,
+            last_message: { text },
+            participant: { name },
+          }) => ({
+            label: `${name || "Unknown"} - ${text?.substring(0, 50) || "No message"}`,
+            value,
+          })),
+          context: {
+            nextCursor: next_cursor,
+          },
+        };
+      },
+    },
+    messageText: {
+      type: "string",
+      label: "Message Text",
+      description: "Message content",
+    },
+    location: {
+      type: "string[]",
+      label: "Locations",
+      description: "Geographic locations to filter",
+      optional: true,
+    },
+    companyUrl: {
+      type: "string[]",
+      label: "Company URLs",
+      description: "LinkedIn company URLs. Eg. `https://www.linkedin.com/company/stripe/`",
+      optional: true,
+    },
+  },
   methods: {
-    // this.$auth contains connected account data
-    authKeys() {
-      console.log(Object.keys(this.$auth));
+    getUrl(path) {
+      return `https://api.linkupapi.com/v1${path}`;
+    },
+    _getHeaders() {
+      return {
+        "x-api-key": this.$auth.api_key,
+        "Content-Type": "application/json",
+      };
+    },
+    _makeRequest({
+      $ = this, path, ...opts
+    } = {}) {
+      return axios($, {
+        ...opts,
+        url: this.getUrl(path),
+        headers: this._getHeaders(),
+      });
+    },
+    post(opts = {}) {
+      return this._makeRequest({
+        method: "POST",
+        ...opts,
+      });
+    },
+    login(opts = {}) {
+      return this.post({
+        path: "/auth/login",
+        ...opts,
+      });
+    },
+    verify(opts = {}) {
+      return this.post({
+        path: "/auth/verify",
+        ...opts,
+      });
+    },
+    getProfileInfo(opts = {}) {
+      return this.post({
+        path: "/profile/info",
+        ...opts,
+      });
+    },
+    searchProfiles(opts = {}) {
+      return this.post({
+        path: "/profile/search",
+        ...opts,
+      });
+    },
+    searchCompanies(opts = {}) {
+      return this.post({
+        path: "/companies/search",
+        ...opts,
+      });
+    },
+    getCompanyInfo(opts = {}) {
+      return this.post({
+        path: "/companies/info",
+        ...opts,
+      });
+    },
+    connectToProfile(opts = {}) {
+      return this.post({
+        path: "/network/connect",
+        ...opts,
+      });
+    },
+    getInvitationsStatus(opts = {}) {
+      return this.post({
+        path: "/network/invitations",
+        ...opts,
+      });
+    },
+    sendMessage(opts = {}) {
+      return this.post({
+        path: "/messages/send-message",
+        ...opts,
+      });
+    },
+    getConversationMessages(opts = {}) {
+      return this.post({
+        path: "/messages/conversation",
+        ...opts,
+      });
+    },
+    getConversations(opts = {}) {
+      return this.post({
+        path: "/messages/inbox",
+        ...opts,
+      });
+    },
+    createComment(opts = {}) {
+      return this.post({
+        path: "/posts/comment",
+        ...opts,
+      });
     },
   },
-};
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/linkupapi",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "description": "Pipedream LinkupAPI Components",
   "main": "linkupapi.app.mjs",
   "keywords": [
@@ -11,5 +11,8 @@
   "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@pipedream/platform": "^3.1.1"
   }
 }