API Reference

npm install @zapier/zapier-sdk
npm install -D @zapier/zapier-sdk-cli @types/node typescript

import { createZapierSdk } from "@zapier/zapier-sdk";

const zapier = createZapierSdk();

import { createZapierSdk } from "@zapier/zapier-sdk";

const zapier = createZapierSdk({
  credentials: {
    clientId: "your_client_id",
    clientSecret: "your_client_secret",
  },
});

import { createZapierSdk } from "@zapier/zapier-sdk";

const zapier = createZapierSdk({
  credentials: "your_zapier_token_here",
});

const { data: profile } = await zapier.getProfile();

const { data: action } = await zapier.getAction({
  app: "example-app",
  actionType: "read",
  action: "example-action",
});

const { data: inputSchema } = await zapier.getActionInputFieldsSchema({
  app: "example-app",
  actionType: "read",
  action: "example-action",
});

// Get first page and a cursor for the second page
const { data: inputFieldChoices, nextCursor } =
  await zapier.listActionInputFieldChoices({
    app: "example-app",
    actionType: "read",
    action: "example-action",
    inputField: "example-input-field",
  });

// Or iterate over all pages
for await (const page of zapier.listActionInputFieldChoices({
  app: "example-app",
  actionType: "read",
  action: "example-action",
  inputField: "example-input-field",
})) {
  // Do something with each page
}

// Or iterate over individual items across all pages
for await (const inputFieldChoice of zapier
  .listActionInputFieldChoices({
    app: "example-app",
    actionType: "read",
    action: "example-action",
    inputField: "example-input-field",
  })
  .items()) {
  // Do something with each inputFieldChoice
}

// Get first page and a cursor for the second page
const { data: rootFields, nextCursor } = await zapier.listActionInputFields({
  app: "example-app",
  actionType: "read",
  action: "example-action",
});

// Or iterate over all pages
for await (const page of zapier.listActionInputFields({
  app: "example-app",
  actionType: "read",
  action: "example-action",
})) {
  // Do something with each page
}

// Or iterate over individual items across all pages
for await (const rootField of zapier
  .listActionInputFields({
    app: "example-app",
    actionType: "read",
    action: "example-action",
  })
  .items()) {
  // Do something with each rootField
}

// Get first page and a cursor for the second page
const { data: actions, nextCursor } = await zapier.listActions({
  app: "example-app",
});

// Or iterate over all pages
for await (const page of zapier.listActions({
  app: "example-app",
})) {
  // Do something with each page
}

// Or iterate over individual items across all pages
for await (const action of zapier
  .listActions({
    app: "example-app",
  })
  .items()) {
  // Do something with each action
}

// Get first page and a cursor for the second page
const { data: actionResults, nextCursor } = await zapier.runAction({
  app: "example-app",
  actionType: "read",
  action: "example-action",
});

// Or iterate over all pages
for await (const page of zapier.runAction({
  app: "example-app",
  actionType: "read",
  action: "example-action",
})) {
  // Do something with each page
}

// Or iterate over individual items across all pages
for await (const actionResult of zapier
  .runAction({
    app: "example-app",
    actionType: "read",
    action: "example-action",
  })
  .items()) {
  // Do something with each actionResult
}

const result = await zapier.apps.appKey();

// Get first page and a cursor for the second page
const { data: actionResults, nextCursor } =
  await zapier.apps.appKey.actionType.actionKey();

// Or iterate over all pages
for await (const page of zapier.apps.appKey.actionType.actionKey()) {
  // Do something with each page
}

// Or iterate over individual items across all pages
for await (const actionResult of zapier.apps.appKey.actionType
  .actionKey()
  .items()) {
  // Do something with each actionResult
}

const { data: app } = await zapier.getApp({
  app: "example-app",
});

// Get first page and a cursor for the second page
const { data: apps, nextCursor } = await zapier.listApps();

// Or iterate over all pages
for await (const page of zapier.listApps()) {
  // Do something with each page
}

// Or iterate over individual items across all pages
for await (const app of zapier.listApps().items()) {
  // Do something with each app
}

const result = await zapier.createClientCredentials({
  name: "example-name",
});

const result = await zapier.deleteClientCredentials({
  clientId: "example-client-id",
});

// Get first page and a cursor for the second page
const { data: clientCredentials, nextCursor } =
  await zapier.listClientCredentials();

// Or iterate over all pages
for await (const page of zapier.listClientCredentials()) {
  // Do something with each page
}

// Or iterate over individual items across all pages
for await (const clientCredentials of zapier.listClientCredentials().items()) {
  // Do something with each clientCredentials
}

const result = await zapier.createConnection({
  app: "example-app",
});

const { data: connection } = await zapier.findFirstConnection();

const { data: connection } = await zapier.findUniqueConnection();

const { data: connection } = await zapier.getConnection();

const {
  data: { url, app, startedAt },
} = await zapier.getConnectionStartUrl({ app: "slack" });
// hand `url` off — print it, DM it, email it, render a button, whatever
const { data: conn } = await zapier.waitForNewConnection({ app, startedAt });

const result = await zapier.getConnectionStartUrl({
  app: "example-app",
});

// Get first page and a cursor for the second page
const { data: connections, nextCursor } = await zapier.listConnections();

// Or iterate over all pages
for await (const page of zapier.listConnections()) {
  // Do something with each page
}

// Or iterate over individual items across all pages
for await (const connection of zapier.listConnections().items()) {
  // Do something with each connection
}

const {
  data: { url, app, startedAt },
} = await zapier.getConnectionStartUrl({ app: "slack" });
// show `url` to the user via the channel they're reading from
const { data: conn } = await zapier.waitForNewConnection({ app, startedAt });

const { data: connection } = await zapier.waitForNewConnection({
  app: "example-app",
  startedAt: 100,
});

const result = await zapier.fetch("https://example.com", {});

const result = await zapier.createTable({
  name: "example-name",
});

const result = await zapier.createTableFields({
  table: "example-table",
  fields: [
    {
      type: "string",
      name: "example-name",
    },
  ],
});

const result = await zapier.createTableRecords({
  table: "example-table",
  records: [
    {
      data: {},
    },
  ],
});

const result = await zapier.deleteTable({
  table: "example-table",
});

const result = await zapier.deleteTableFields({
  table: "example-table",
  fields: ["example-field"],
});

const result = await zapier.deleteTableRecords({
  table: "example-table",
  records: ["example-record"],
});

const { data: table } = await zapier.getTable({
  table: "example-table",
});

const { data: record } = await zapier.getTableRecord({
  table: "example-table",
  record: "example-record",
});

// Get first page and a cursor for the second page
const { data: fields, nextCursor } = await zapier.listTableFields({
  table: "example-table",
});

// Or iterate over all pages
for await (const page of zapier.listTableFields({
  table: "example-table",
})) {
  // Do something with each page
}

// Or iterate over individual items across all pages
for await (const field of zapier
  .listTableFields({
    table: "example-table",
  })
  .items()) {
  // Do something with each field
}

// Get first page and a cursor for the second page
const { data: records, nextCursor } = await zapier.listTableRecords({
  table: "example-table",
});

// Or iterate over all pages
for await (const page of zapier.listTableRecords({
  table: "example-table",
})) {
  // Do something with each page
}

// Or iterate over individual items across all pages
for await (const record of zapier
  .listTableRecords({
    table: "example-table",
  })
  .items()) {
  // Do something with each record
}

// Get first page and a cursor for the second page
const { data: tables, nextCursor } = await zapier.listTables();

// Or iterate over all pages
for await (const page of zapier.listTables()) {
  // Do something with each page
}

// Or iterate over individual items across all pages
for await (const table of zapier.listTables().items()) {
  // Do something with each table
}

const result = await zapier.updateTableRecords({
  table: "example-table",
  records: [
    {
      id: "example-id",
      data: {},
    },
  ],
});

const result = await zapier.cancelDurableRun({
  run: "example-run",
});

const result = await zapier.createWorkflow({
  name: "example-name",
});

const result = await zapier.deleteWorkflow({
  workflow: "example-workflow",
});