Connect API & SDK reference

import {
  createBackendClient,
  type BackendClient,
  type BackendClientOpts,
  type ConnectAPIResponse,
  type ConnectTokenCreateOpts,
  type ConnectTokenResponse,
} from "@pipedream/sdk/server";
 
const clientOpts: BackendClientOpts = {
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
};
const pd: BackendClient = createBackendClient(clientOpts);
 
const requestOpts: ConnectTokenCreateOpts = {
  // The end user's ID in your system
  external_user_id: "{your_external_user_id}",
  // The allowed origins for the token (required for client-side requests)
  allowed_origins: ["http://localhost:3000", "https://example.com"],
};
const response: ConnectTokenResponse = await pd.createConnectToken(requestOpts);
 
const {
  token,            // The token you'll pass to the frontend
  expires_at,       // The token's expiration date
  connect_link_url, // The URL to redirect the user to for the Connect Link flow
}: {
  token: string,
  expires_at: string,
  connect_link_url: string,
} = response;

import { createBackendClient } from "@pipedream/sdk/server";
 
const pd = createBackendClient({
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
});
 
const { token, expires_at } = await pd.createConnectToken({
  external_user_id: "{your_external_user_id}", // The end user's ID in your system
  allowed_origins: ["http://localhost:3000", "https://example.com"], // The allowed origins for the token (required for client-side requests)
});

# First, obtain an OAuth access token
curl -X POST https://api.pipedream.com/v1/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "client_credentials",
    "client_id": "{oauth_client_id}",
    "client_secret": "{oauth_client_secret}"
  }'
 
# The response will include an access_token. Use it in the Authorization header below.
 
curl -X POST https://api.pipedream.com/v1/connect/{project_id}/tokens \
  -H "Content-Type: application/json" \
  -H "X-PD-Environment: development" \
  -H "Authorization: Bearer {access_token}" \
  -d '{
    "external_user_id": "{your_external_user_id}",
    "allowed_origins": [
      "http://localhost:3000",
      "https://example.com"
    ],
  }'

import {
  createBackendClient,
  type Account,
  type BackendClientOpts,
  type BackendClient,
  type GetAccountOpts,
  type GetAccountsResponse,
} from "@pipedream/sdk/server";
 
const clientOpts: BackendClientOpts = {
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
};
const pd: BackendClient = createBackendClient(clientOpts);
 
const requestOpts: GetAccountOpts = {
  app: "github", // optional, filter by app
  external_user_id: "user-abc-123", // optional, filter by external user ID
  include_credentials: true, // optional, set to true to include credentials
};
const response: GetAccountsResponse = await pd.getAccounts(requestOpts);
 
// These may contain credentials, which you should never return to the client
const {
  data
}: {
  data: Account[]
} = response;

import { createBackendClient } from "@pipedream/sdk/server";
 
const pd = createBackendClient({
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
});
 
const accounts = await pd.getAccounts({
  app: "github", // optional, filter by app
  external_user_id: "user-abc-123", // optional, filter by external user ID
  include_credentials: true, // optional, set to true to include credentials
});
 
// Parse and return the data you need. These may contain credentials,
// which you should never return to the client

# First, obtain an OAuth access token
curl -X POST https://api.pipedream.com/v1/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "client_credentials",
    "client_id": "{oauth_client_id}",
    "client_secret": "{oauth_client_secret}"
  }'
 
# The response will include an access_token. Use it in the Authorization header below.
 
curl -X GET \
  -G \
  "https://api.pipedream.com/v1/connect/{project_id}/accounts" \
  -H "Authorization: Bearer {access_token}" \
  -d "app=github" \ # optional, filter by app
  -d "external_user_id=user-abc-123" \ # optional, filter by external user ID
  -d "include_credentials=true" # optional, include credentials
 
 
# Parse and return the data you need. These may contain credentials,
# which you should never return to the client

import {
  createBackendClient,
  type Account,
  type BackendClient,
  type BackendClientOpts,
  type GetAccountOpts,
} from "@pipedream/sdk/server";
 
const clientOpts: BackendClientOpts = {
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
};
const pd: BackendClient = createBackendClient(clientOpts);
 
const accountId: string = "{account_id}"; // Replace with your account ID
const requestOpts: GetAccountOpts = {
  include_credentials: true, // optional, set to true to include credentials
};
// These may contain credentials, which you should never return to the client.
const account: Account = await pd.getAccountById(accountId, requestOpts);

import { createBackendClient } from "@pipedream/sdk/server";
 
const pd = createBackendClient({
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
});
 
const accountId = "{account_id}"; // Replace with your account ID
 
const account = await pd.getAccountById(accountId, {
  include_credentials: true, // optional, set to true to include credentials
});
 
// Parse and return the data you need. These may contain credentials,
// which you should never return to the client

# First, obtain an OAuth access token
curl -X POST https://api.pipedream.com/v1/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "client_credentials",
    "client_id": "{oauth_client_id}",
    "client_secret": "{oauth_client_secret}"
  }'
 
# The response will include an access_token. Use it in the Authorization header below.
 
curl -X GET \
  -G \
  "https://api.pipedream.com/v1/connect/{project_id}/accounts/{account_id}" \
  -H "Authorization: Bearer {access_token}" \
  -d "app=github" \ # optional, filter by app
  -d "external_user_id=user-abc-123" \ # optional, filter by external user ID
  -d "include_credentials=true" # optional, include credentials
 
# Parse and return the data you need. These may contain credentials,
# which you should never return to the client

import {
  createBackendClient,
  type BackendClient,
  type BackendClientOpts,
} from "@pipedream/sdk/server";
 
const clientOpts: BackendClientOpts = {
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
};
const pd: BackendClient = createBackendClient(clientOpts);
 
const accountId: string = "{account_id}"; // Replace with your account ID
await pd.deleteAccount(accountId);
 
// You can return a message or handle any post-deletion logic here.

import { createBackendClient } from "@pipedream/sdk/server";
 
const pd = createBackendClient({
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
});
 
const accountId = "{account_id}"; // Replace with your account ID
await pd.deleteAccount(accountId);
 
// You can return a message or handle any post-deletion logic here.

# First, obtain an OAuth access token
curl -X POST https://api.pipedream.com/v1/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "client_credentials",
    "client_id": "{oauth_client_id}",
    "client_secret": "{oauth_client_secret}"
  }'
 
# The response will include an access_token. Use it in the Authorization header below.
 
curl -X DELETE "https://api.pipedream.com/v1/connect/{project_id}/accounts/{account_id}" \
  -H "Authorization: Bearer {access_token}"

import {
  createBackendClient,
  type BackendClient,
  type BackendClientOpts,
} from "@pipedream/sdk/server";
 
const clientOpts: BackendClientOpts = {
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
};
const pd: BackendClient = createBackendClient(clientOpts);
 
const appId: string = "{app_id}"; // Replace with the app ID
await pd.deleteAccountsByApp(appId);
 
// You can return a message or handle any post-deletion logic here.

import { createBackendClient } from "@pipedream/sdk/server";
 
const pd = createBackendClient({
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
});
 
const appId = "{app_id}"; // Replace with the app ID
await pd.deleteAccountsByApp(appId);
 
// You can return a message or handle any post-deletion logic here.

# First, obtain an OAuth access token
curl -X POST https://api.pipedream.com/v1/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "client_credentials",
    "client_id": "{oauth_client_id}",
    "client_secret": "{oauth_client_secret}"
  }'
 
# The response will include an access_token. Use it in the Authorization header below.
 
curl -X DELETE "https://api.pipedream.com/v1/connect/{project_id}/accounts/{account_id}" \
  -H "Authorization: Bearer {access_token}"

import {
  createBackendClient,
  type BackendClient,
  type BackendClientOpts,
} from "@pipedream/sdk/server";
 
const clientOpts: BackendClientOpts = {
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
};
const pd: BackendClient = createBackendClient(clientOpts);
 
const externalId: string = "{external_user_id}"; // Replace with your external user ID
await pd.deleteExternalUser(externalId);
 
// You can return a message or handle any post-deletion logic here.

import { createBackendClient } from "@pipedream/sdk/server";
 
const pd = createBackendClient({
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
});
 
const externalId = "{external_user_id}"; // Replace with your external user ID
await pd.deleteExternalUser(externalId);
 
// You can return a message or handle any post-deletion logic here.

# First, obtain an OAuth access token
curl -X POST https://api.pipedream.com/v1/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "client_credentials",
    "client_id": "{oauth_client_id}",
    "client_secret": "{oauth_client_secret}"
  }'
 
# The response will include an access_token. Use it in the Authorization header below.
 
curl -X DELETE "https://api.pipedream.com/v1/connect/{project_id}/users/{external_user_id}" \
  -H "Authorization: Bearer {access_token}"

import {
  createBackendClient,
  type BackendClient,
  type BackendClientOpts,
  type GetComponentsOpts,
  type GetComponentsResponse,
  type V1Component,
} from "@pipedream/sdk/server";
 
const clientOpts: BackendClientOpts = {
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
};
const pd: BackendClient = createBackendClient(clientOpts);
 
// Retrieve components containing the word "issue" in their name, belonging to
// the Gitlab app
const requestOpts: GetComponentsOpts = {
  app: "gitlab",
  q: "issue",
};
const response: GetComponentsResponse = await pd.getComponents(requestOpts);
 
const {
  data  // The list of components for the Gitlab app and query `q`
}: {
  data: Omit<V1Component, "configurable_props">[];
} = response;

import { createBackendClient } from "@pipedream/sdk/server";
 
const pd = createBackendClient({
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
});
 
// Retrieve components containing the word "issue" in their name, belonging to
// the Gitlab app
const { data: components } = await pd.getComponents({
  app: "gitlab",
  q: "issue",
});
 
// Parse and return the data you need

# First, obtain an OAuth access token
curl -X POST https://api.pipedream.com/v1/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "client_credentials",
    "client_id": "{oauth_client_id}",
    "client_secret": "{oauth_client_secret}"
  }'
 
# The response will include an access_token. Use it in the Authorization header below.
# This request will fetch the first 3 components for the Gitlab app that contain
# the word "issue" in their name
curl -X GET "https://api.pipedream.com/v1/connect/{your_project_id}/components?app=gitlab&limit=3&q=issue" \
  -H "Authorization: Bearer {access_token}"

import {
  createBackendClient,
  type BackendClient,
  type BackendClientOpts,
  type GetComponentOpts,
  type GetComponentResponse,
  type V1Component,
} from "@pipedream/sdk/server";
 
const clientOpts: BackendClientOpts = {
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
};
const pd: BackendClient = createBackendClient(clientOpts);
 
// Retrieve the "New Issue (Instant)" component for the Gitlab app
const requestOpts: GetComponentOpts = {
  key: "gitlab-new-issue",
};
const response: GetComponentResponse = await pd.getComponent(requestOpts);
 
const {
  data  // The "New Issue (Instant)" component for the Gitlab app
}: {
  data: V1Component;
} = response;

import { createBackendClient } from "@pipedream/sdk/server";
 
const pd = createBackendClient({
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
});
 
// Retrieve the "New Issue (Instant)" component for the Gitlab app
const { data: component } = await pd.getComponent({
  key: "gitlab-new-issue",
});
 
// Parse and return the data you need

# First, obtain an OAuth access token
curl -X POST https://api.pipedream.com/v1/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "client_credentials",
    "client_id": "{oauth_client_id}",
    "client_secret": "{oauth_client_secret}"
  }'
 
# The response will include an access_token. Use it in the Authorization header below.
# This request will fetch the "New Issue (Instant)" component for the Gitlab app.
curl -X GET "https://api.pipedream.com/v1/connect/{your_project_id}/components/gitlab-new-issue" \
  -H "Authorization: Bearer {access_token}"

import {
  createBackendClient,
  type BackendClient,
  type BackendClientOpts,
  type ConfigureComponentOpts,
  type ConfigureComponentResponse,
  type PropOption,
} from "@pipedream/sdk/server";
 
const clientOpts: BackendClientOpts = {
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
};
const pd: BackendClient = createBackendClient(clientOpts);
 
// Retrieve the configuration options for the "projectId" prop of the "List
// Commits" component for the Gitlab app.
const requestOpts: ConfigureComponentOpts = {
  componentId: {
    key: "gitlab-list-commits",
  },
  configuredProps: {
    gitlab: {
      authProvisionId: "apn_kVh9AoD",
    },
  },
  externalUserId: "jverce",
  propName: "projectId",
};
const response: ConfigureComponentResponse = await pd.configureComponent(requestOpts);
 
const {
  options,        // The list of options for the "projectId" prop
  stringOptions,  // The list of string options for the "projectId" prop
  errors,         // Any errors that occurred during the configuration
}: {
  options: PropOption[];
  stringOptions: string[];
  errors: string[];
} = response;

import { createBackendClient } from "@pipedream/sdk/server";
 
const pd = createBackendClient({
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
});
 
// Retrieve the configuration options for the "projectId" prop of the "List
// Commits" component for the Gitlab app.
const { options } = await pd.configureComponent({
  componentId: {
    key: "gitlab-list-commits",
  },
  configuredProps: {
    gitlab: {
      authProvisionId: "apn_kVh9AoD",
    },
  },
  externalUserId: "jverce",
  propName: "projectId",
});
 
// Parse and return the data you need

# First, obtain an OAuth access token
curl -X POST https://api.pipedream.com/v1/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "client_credentials",
    "client_id": "{oauth_client_id}",
    "client_secret": "{oauth_client_secret}"
  }'
 
# The response will include an access_token. Use it in the Authorization header below.
# This request will fetch the configuration options for the "projectId" prop of
# the "List Commits" component for the Gitlab app.
 
echo '{
  "external_user_id": "jverce",
  "id": "gitlab-list-commits",
  "prop_name": "projectId",
  "configured_props": {
    "gitlab": {
      "authProvisionId": "apn_kVh9AoD"
    }
  }
}' > data.json
 
curl -X POST "https://api.pipedream.com/v1/connect/{your_project_id}/components/configure" \
  -H "Authorization: Bearer {access_token}" \
  -H "Content-Type: application/json" \
  -d @data.json

import {
  createBackendClient,
  type BackendClient,
  type BackendClientOpts,
  type ConfigurableProps,
  type ReloadComponentPropsOpts,
  type ReloadComponentPropsResponse,
} from "@pipedream/sdk/server";
 
const clientOpts: BackendClientOpts = {
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
};
const pd: BackendClient = createBackendClient(clientOpts);
 
// Retrieve the configuration options for the "Add Single Row" component for
// the Google Sheets app. Note that the `sheetId` prop is a dynamic prop.
const requestOpts: ReloadComponentPropsOpts = {
  componentId: {
    key: "google_sheets-add-single-row",
  },
  configuredProps: {
    googleSheets: {
      authProvisionId: "apn_V1hMoE7",
    },
    sheetId: "1BfWjFF2dTW_YDiLISj5N9nKCUErShgugPS434liyytg",
  },
  externalUserId: "jay",
};
const response: ReloadComponentPropsResponse = await pd.reloadComponentProps(requestOpts);
 
const {
  configurableProps,  // The new set of props
  id: dynamicPropsId, // The ID of the last prop reconfiguration
}: {
  configurableProps: ConfigurableProps,
  id: string,
} = response.dynamicProps;

import { createBackendClient } from "@pipedream/sdk/server";
 
const pd = createBackendClient({
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
});
 
// Retrieve the configuration options for the "Add Single Row" component for
// the Google Sheets app. Note that the `sheetId` prop is a dynamic prop.
const { dynamicProps } = await pd.reloadComponentProps({
  componentId: {
    key: "google_sheets-add-single-row",
  },
  configuredProps: {
    googleSheets: {
      authProvisionId: "apn_V1hMoE7",
    },
    sheetId: "1BfWjFF2dTW_YDiLISj5N9nKCUErShgugPS434liyytg",
  },
  externalUserId: "jay",
});
 
const {
  configurableProps,  // The new set of props
  id: dynamicPropsId, // The ID of the last prop reconfiguration
} = dynamicProps;
 
// Parse and return the data you need

# First, obtain an OAuth access token
curl -X POST https://api.pipedream.com/v1/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "client_credentials",
    "client_id": "{oauth_client_id}",
    "client_secret": "{oauth_client_secret}"
  }'
 
# The response will include an access_token. Use it in the Authorization header below.
# This request will fetch the new set of props for the "Add Single Row" component
# for the Google Sheets app. Note that the `sheetId` prop is a dynamic prop.
 
echo '{
  "external_user_id": "jay",
  "id": "google_sheets-add-single-row",
  "configured_props": {
    "googleSheets": {
      "authProvisionId": "apn_V1hMoE7"
    },
    "sheetId": "1BfWjFF2dTW_YDiLISj5N9nKCUErShgugPS434liyytg"
  }
}' > data.json
 
curl -X POST "https://api.pipedream.com/v1/connect/{your_project_id}/components/props" \
  -H "Authorization: Bearer {access_token}" \
  -H "Content-Type: application/json" \
  -d @data.json

import {
  createBackendClient,
  type BackendClient,
  type BackendClientOpts,
  type RunActionOpts,
  type RunActionResponse,
} from "@pipedream/sdk/server";
 
const clientOpts: BackendClientOpts = {
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
};
const pd: BackendClient = createBackendClient(clientOpts);
 
// Run the "List Commits" action for the Gitlab app
const requestOpts: RunActionOpts = {
  actionId: {
    key: "gitlab-list-commits",
  },
  configuredProps: {
    gitlab: {
      authProvisionId: "apn_kVh9AoD",
    },
    projectId: 45672541,
    refName: "main"
  },
  externalUserId: "jverce",
};
const response: RunActionResponse = await pd.runAction(requestOpts);
 
const {
  exports,  // The named exports produced by the action
  os,       // The observations produced by the action
  ret,      // The value returned by the action
}: {
  exports: unknown,
  os: unknown[],
  ret: unknown,
} = response;

import { createBackendClient } from "@pipedream/sdk/server";
 
const pd = createBackendClient({
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
});
 
// Run the "List Commits" action for the Gitlab app
const {
  exports,  // The named exports produced by the action
  os,       // The observations produced by the action
  ret,      // The value returned by the action
} = await pd.runAction({
  actionId: {
    key: "gitlab-list-commits",
  },
  configuredProps: {
    gitlab: {
      authProvisionId: "apn_kVh9AoD",
    },
    projectId: 45672541,
    refName: "main"
  },
  externalUserId: "jverce",
});
 
// Parse and return the data you need

# First, obtain an OAuth access token
curl -X POST https://api.pipedream.com/v1/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "client_credentials",
    "client_id": "{oauth_client_id}",
    "client_secret": "{oauth_client_secret}"
  }'
 
# The response will include an access_token. Use it in the Authorization header below.
# This request will run the "List Commits" action for the Gitlab app.
 
echo '{
  "external_user_id": "jverce",
  "id": "gitlab-list-commits",
  "configured_props": {
    "gitlab": {
      "authProvisionId": "apn_kVh9AoD"
    },
    "projectId": 45672541,
    "refName": "main"
  }
}' > data.json
 
curl -X POST "https://api.pipedream.com/v1/connect/{your_project_id}/actions/run" \
  -H "Authorization: Bearer {access_token}" \
  -H "Content-Type: application/json" \
  -d @data.json

import {
  createBackendClient,
  type BackendClient,
  type BackendClientOpts,
  type DeployTriggerOpts,
  type DeployTriggerResponse,
} from "@pipedream/sdk/server";
 
const clientOpts: BackendClientOpts = {
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
};
const pd: BackendClient = createBackendClient(clientOpts);
 
// Deploy the "New Issue (Instant)" trigger for the Gitlab app
const requestOpts: DeployTriggerOpts = {
  triggerId: {
    key: "gitlab-new-issue",
  },
  configuredProps: {
    gitlab: {
      authProvisionId: "apn_kVh9AoD",
    },
    projectId: 45672541,
  },
  externalUserId: "jverce",
  webhookUrl: "https://events.example.com/gitlab-new-issue",
};
const response: DeployTriggerResponse = await pd.deployTrigger(requestOpts);
 
const {
  id: triggerId,      // The unique ID of the deployed trigger
  name: triggerName,  // The name of the deployed trigger
  owner_id: userId,   // The unique ID in Pipedream of your user
}: {
  id: string,
  name: string,
  owner_id: string,
} = response.data;

import { createBackendClient } from "@pipedream/sdk/server";
 
const pd = createBackendClient({
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
});
 
// Deploy the "New Issue (Instant)" trigger for the Gitlab app
const { data: deployedTrigger } = await pd.deployTrigger({
  triggerId: {
    key: "gitlab-new-issue",
  },
  configuredProps: {
    gitlab: {
      authProvisionId: "apn_kVh9AoD",
    },
    projectId: 45672541,
  },
  externalUserId: "jverce",
  webhookUrl: "https://events.example.com/gitlab-new-issue",
});
 
const {
  id: triggerId,      // The unique ID of the deployed trigger
  name: triggerName,  // The name of the deployed trigger
  owner_id: userId,   // The unique ID in Pipedream of your user
} = deployedTrigger;
 
// Parse and return the data you need

# First, obtain an OAuth access token
curl -X POST https://api.pipedream.com/v1/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "client_credentials",
    "client_id": "{oauth_client_id}",
    "client_secret": "{oauth_client_secret}"
  }'
 
# The response will include an access_token. Use it in the Authorization header below.
# This request will deploy the "New Issue (Instant)" trigger for the Gitlab app.
 
echo '{
  "external_user_id": "jverce",
  "id": "gitlab-new-issue",
  "configured_props": {
    "gitlab": {
      "authProvisionId": "apn_kVh9AoD"
    },
    "projectId": 45672541,
  },
  "webhook_url": "https://events.example.com/gitlab-new-issue"
}' > data.json
 
curl -X POST "https://api.pipedream.com/v1/connect/{your_project_id}/triggers/deploy" \
  -H "Authorization: Bearer {access_token}" \
  -H "Content-Type: application/json" \
  -d @data.json

import {
  createBackendClient,
  type BackendClient,
  type BackendClientOpts,
  type GetTriggersOpts,
  type GetTriggersResponse,
  type V1DeployedComponent,
} from "@pipedream/sdk/server";
 
const clientOpts: BackendClientOpts = {
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
};
const pd: BackendClient = createBackendClient(clientOpts);
 
// List all deployed triggers for the specified user
const requestOpts: GetTriggersOpts = {
  externalUserId: "jverce",
};
const response: GetTriggersResponse = await pd.getTriggers(requestOpts);
 
const {
  data: triggers,  // The list of deployed triggers
}: {
  data: V1DeployedComponent[],
} = response;

import {
  createBackendClient,
} from "@pipedream/sdk/server";
 
const pd = createBackendClient({
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
});
 
// List all deployed triggers for the specified user
const { data: triggers } = await pd.getTriggers({
  externalUserId: "jverce"
});
 
// Parse and return the data you need

# First, obtain an OAuth access token
curl -X POST https://api.pipedream.com/v1/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "client_credentials",
    "client_id": "{oauth_client_id}",
    "client_secret": "{oauth_client_secret}"
  }'
 
# The response will include an access_token. Use it in the Authorization header below.
# This request will list all deployed triggers for the specified user.
 
curl -X GET \
  -G \
  "https://api.pipedream.com/v1/connect/{your_project_id}/deployed-triggers" \
  -H "Authorization: Bearer {access_token}" \
  -H "Content-Type: application/json" \
  -H "x-pd-environment: development" \
  -d "external_user_id={external_user_id}"

import {
  createBackendClient,
  type BackendClient,
  type BackendClientOpts,
  type GetTriggerOpts,
  type GetTriggerResponse,
  type V1DeployedComponent,
} from "@pipedream/sdk/server";
 
const clientOpts: BackendClientOpts = {
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
};
const pd: BackendClient = createBackendClient(clientOpts);
 
// Retrieve the deployed trigger for the specified user
const requestOpts: GetTriggerOpts = {
  id: "dc_gzumK2e",
  externalUserId: "jverce",
};
const response: GetTriggerResponse = await pd.getTrigger(requestOpts);
 
const {
  data: trigger,  // The deployed trigger
}: {
  data: V1DeployedComponent,
} = response;

import {
  createBackendClient,
} from "@pipedream/sdk/server";
 
const pd = createBackendClient({
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
});
 
// Retrieve the deployed trigger for the specified user
const { data: trigger } = await pd.getTrigger({
  id: "dc_gzumK2e",
  externalUserId: "jverce"
});
 
// Parse and return the data you need

# First, obtain an OAuth access token
curl -X POST https://api.pipedream.com/v1/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "client_credentials",
    "client_id": "{oauth_client_id}",
    "client_secret": "{oauth_client_secret}"
  }'
 
# The response will include an access_token. Use it in the Authorization header below.
# This request will list all deployed triggers for the specified user.
 
curl -X GET \
  -G \
  "https://api.pipedream.com/v1/connect/{your_project_id}/deployed-triggers/{dcid}/" \
  -H "Authorization: Bearer {access_token}" \
  -H "Content-Type: application/json" \
  -H "x-pd-environment: development" \
  -d "external_user_id={external_user_id}"

import {
  createBackendClient,
  type BackendClient,
  type BackendClientOpts,
  type DeleteTriggerOpts,
} from "@pipedream/sdk/server";
 
const clientOpts: BackendClientOpts = {
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
};
const pd: BackendClient = createBackendClient(clientOpts);
 
// Delete the deployed trigger for the specified user.
const requestOpts: DeleteTriggerOpts = {
  id: "dc_gzumK2e",
  externalUserId: "jverce",
};
 
// The method doesn't return any data.
await pd.deleteTrigger(requestOpts);

import {
  createBackendClient,
} from "@pipedream/sdk/server";
 
const pd = createBackendClient({
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
});
 
// Delete the deployed trigger for the specified user. The method doesn't return
// any data.
await pd.deleteTrigger({
  id: "dc_gzumK2e",
  externalUserId: "jverce"
});

# First, obtain an OAuth access token
curl -X POST https://api.pipedream.com/v1/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "client_credentials",
    "client_id": "{oauth_client_id}",
    "client_secret": "{oauth_client_secret}"
  }'
 
# The response will include an access_token. Use it in the Authorization header below.
# This request will list all deployed triggers for the specified user.
 
curl -X DELETE \
  -G \
  "https://api.pipedream.com/v1/connect/{your_project_id}/deployed-triggers/{dcid}/" \
  -H "Authorization: Bearer {access_token}" \
  -H "Content-Type: application/json" \
  -H "x-pd-environment: development" \
  -d "external_user_id={external_user_id}"

import {
  createBackendClient,
  type BackendClient,
  type BackendClientOpts,
  type GetTriggerEventsOpts,
  type GetTriggerEventsResponse,
  type V1EmittedEvent,
} from "@pipedream/sdk/server";
 
const clientOpts: BackendClientOpts = {
  environment: "development", // change to production if running for a test production account, or in production
  credentials: {
    clientId: "{oauth_client_id}",
    clientSecret: "{oauth_client_secret}",
  },
  projectId: "{your_project_id}"
};
const pd: BackendClient = createBackendClient(clientOpts);
 
// List the last 10 events emitted by the deployed trigger of the specified user
const requestOpts: GetTriggerEventsOpts = {
  id: "dc_gzumK2e",
  externalUserId: "jverce",
};
const response: GetTriggerEventsResponse = await pd.getTriggerEvents(requestOpts);
 
const {
  data: events,  // The list of events emitted by the trigger
}: {
  data: V1EmittedEvent[],
} = response;