ExploreConnectDocsChangelogPricingTemplatesPartnersString
Sign in
Sign up
← Supabase + OpenSRS integrations

Update DNS Records with OpenSRS API on New Webhook Event (Instant) from Supabase API

Pipedream makes it easy to connect APIs for OpenSRS, Supabase and 2,900+ other apps remarkably fast.

Trigger workflow on
New Webhook Event (Instant) from the Supabase API
Next, do this
Update DNS Records with the OpenSRS API
No credit card required
Intro to Pipedream
▶
Watch us build a workflow
Watch us build a workflow
8 min
Watch now ➜

Trusted by 1,000,000+ developers from startups to Fortune 500 companies

Adyen logo
Appcues logo
Bandwidth logo
Checkr logo
ChartMogul logo
Dataminr logo
Gopuff logo
Gorgias logo
LinkedIn logo
Logitech logo
Replicated logo
Rudderstack logo
SAS logo
Scale AI logo
Webflow logo
Warner Bros. logo
Adyen logo
Appcues logo
Bandwidth logo
Checkr logo
ChartMogul logo
Dataminr logo
Gopuff logo
Gorgias logo
LinkedIn logo
Logitech logo
Replicated logo
Rudderstack logo
SAS logo
Scale AI logo
Webflow logo
Warner Bros. logo

Developers ♥ Pipedream

Getting Started

This integration creates a workflow with a Supabase trigger and OpenSRS action. When you configure and deploy the workflow, it will run on Pipedream's servers 24x7 for free.

  1. Select this integration
  2. Configure the New Webhook Event (Instant) trigger
    1. Connect your Supabase account
    2. Configure Table
    3. Optional- Configure Row Identifier
  3. Configure the Update DNS Records action
    1. Connect your OpenSRS account
    2. Configure Domain
    3. Select a Nameservers OK
    4. Configure Number of A Records
    5. Configure Number of AAAA Records
    6. Configure Number of CNAME Records
    7. Configure Number of MX Records
    8. Configure Number of TXT Records
    9. Optional- Configure JSON Output
  4. Deploy the workflow
  5. Send a test event to validate your setup
  6. 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 Webhook Event (Instant) on Supabase
Description:Emit new event for every `insert`, `update`, or `delete` operation in a table. This source requires user configuration using the Supabase website. More information in the README. [Also see documentation here](https://supabase.com/docs/guides/database/webhooks#creating-a-webhook)
Version:0.0.6
Key:supabase-new-webhook-event

Supabase Overview

Supabase is a real-time backend-as-a-service that provides developers with a suite of tools to quickly build and scale their applications. It offers database storage, authentication, instant APIs, and real-time subscriptions. With the Supabase API, you can perform CRUD operations on your database, manage users, and listen to database changes in real time. When integrated with Pipedream, you can automate workflows that react to these database events, synchronize data across multiple services, or streamline user management processes.

Trigger Code

import base from "../common/base.mjs";
import constants from "../../common/constants.mjs";

export default {
  key: "supabase-new-webhook-event",
  name: "New Webhook Event (Instant)",
  description: "Emit new event for every `insert`, `update`, or `delete` operation in a table. This source requires user configuration using the Supabase website. More information in the README. [Also see documentation here](https://supabase.com/docs/guides/database/webhooks#creating-a-webhook)",
  version: "0.0.6",
  type: "source",
  props: {
    ...base.props,
    http: {
      type: "$.interface.http",
    },
  },
  hooks: {
    async deploy() {
      const client = await this.supabase._client();
      const query = client
        .from(this.table)
        .select()
        .range(0, constants.HISTORICAL_EVENT_LIMIT);
      const { data } = await query;
      for (const row of data) {
        this.$emit({
          record: row,
        }, {
          summary: "Historical row in table",
        });
      }
    },
  },
  async run(event) {
    const { body: data } = event;
    let summary = `New ${data.type} event in table`;
    if (data.record?.[this.rowIdentifier]) {
      summary = `${summary}: ${data.record[this.rowIdentifier]}`;
    }
    this.$emit(data, {
      summary,
    });
  },
};

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.
LabelPropTypeDescription
SupabasesupabaseappThis component uses the Supabase app.
Tabletablestring

The name of the table to watch for new rows

Row IdentifierrowIdentifierstring

The column name to use as the row identifier

N/Ahttp$.interface.httpThis component uses $.interface.http to generate a unique URL when the component is first instantiated. Each request to the URL will trigger the run() method of the component.

Trigger Authentication

Supabase uses API keys for authentication. When you connect your Supabase account, Pipedream securely stores the keys so you can easily authenticate to Supabase APIs in both code and no-code steps.

About Supabase

Supabase is an open source Firebase alternative.

Action

Update DNS Records on OpenSRS
Description:Update DNS records for a specified domain. [See the documentation](https://domains.opensrs.guide/docs/set_dns_zone-).
Version:0.0.2
Key:opensrs-update-dns-records

Action Code

import app from "../../opensrs.app.mjs";
import utils from "../../common/utils.mjs";
import constants from "../../common/constants.mjs";

export default {
  key: "opensrs-update-dns-records",
  name: "Update DNS Records",
  description: "Update DNS records for a specified domain. [See the documentation](https://domains.opensrs.guide/docs/set_dns_zone-).",
  version: "0.0.2",
  annotations: {
    destructiveHint: true,
    openWorldHint: true,
    readOnlyHint: false,
  },
  type: "action",
  props: {
    app,
    domain: {
      propDefinition: [
        app,
        "domain",
      ],
    },
    nameserversOk: {
      type: "string",
      label: "Nameservers OK",
      description: "Indicates whether the domain is set up to use the OpenSRS nameservers.",
      default: "0",
      options: [
        {
          label: "Domain is not set up to use the OpenSRS nameservers",
          value: "0",
        },
        {
          label: "Domain is set up to use the OpenSRS nameservers",
          value: "1",
        },
      ],
    },
    numberOfARecords: {
      type: "integer",
      label: "Number of A Records",
      description: "Number of A records to update",
      default: 0,
      reloadProps: true,
    },
    numberOfAAAARecords: {
      type: "integer",
      label: "Number of AAAA Records",
      description: "Number of AAAA records to update",
      default: 0,
      reloadProps: true,
    },
    numberOfCNAMERecords: {
      type: "integer",
      label: "Number of CNAME Records",
      description: "Number of CNAME records to update",
      default: 0,
      reloadProps: true,
    },
    numberOfMXRecords: {
      type: "integer",
      label: "Number of MX Records",
      description: "Number of MX records to update",
      default: 0,
      reloadProps: true,
    },
    numberOfTXTRecords: {
      type: "integer",
      label: "Number of TXT Records",
      description: "Number of TXT records to update",
      default: 0,
      reloadProps: true,
    },
    jsonOutput: {
      type: "boolean",
      label: "JSON Output",
      description: "Whether to output the response in JSON format.",
      optional: true,
      default: true,
    },
  },
  additionalProps() {
    const {
      numberOfARecords,
      numberOfAAAARecords,
      numberOfCNAMERecords,
      numberOfMXRecords,
      numberOfTXTRecords,
      getARecordPropDefinitions,
      getAAAARecordPropDefinitions,
      getCNAMERecordPropDefinitions,
      getMXRecordPropDefinitions,
      getTXTRecordPropDefinitions,
    } = this;

    const aRecords = utils.getAdditionalProps({
      numberOfFields: numberOfARecords,
      fieldName: "a",
      getPropDefinitions: getARecordPropDefinitions,
    });

    const aaaaRecords = utils.getAdditionalProps({
      numberOfFields: numberOfAAAARecords,
      fieldName: "aaaa",
      getPropDefinitions: getAAAARecordPropDefinitions,
    });

    const cnameRecords = utils.getAdditionalProps({
      numberOfFields: numberOfCNAMERecords,
      fieldName: "cname",
      getPropDefinitions: getCNAMERecordPropDefinitions,
    });

    const mxRecords = utils.getAdditionalProps({
      numberOfFields: numberOfMXRecords,
      fieldName: "mx",
      getPropDefinitions: getMXRecordPropDefinitions,
    });

    const txtRecords = utils.getAdditionalProps({
      numberOfFields: numberOfTXTRecords,
      fieldName: "txt",
      getPropDefinitions: getTXTRecordPropDefinitions,
    });

    return Object.assign({}, aRecords, aaaaRecords, cnameRecords, mxRecords, txtRecords);
  },
  methods: {
    getARecordPropDefinitions({
      prefix, label,
    } = {}) {
      return {
        [`${prefix}ipAddress`]: {
          type: "string",
          label: `${label} - IP Address`,
          description: "The IPv4 address for the A record. A numeric address that computers recognize eg. `123.45.54.123`.",
        },
        [`${prefix}subdomain`]: {
          type: "string",
          label: `${label} - Subdomain`,
          description: "The subdomain for the A record. The third level of the domain name, such as `www` or `ftp`.",
          optional: true,
        },
      };
    },
    getAAAARecordPropDefinitions({
      prefix, label,
    } = {}) {
      return {
        [`${prefix}ipv6Address`]: {
          type: "string",
          label: `${label} - IPv6 Address`,
          description: "The IPv6 address for the AAAA record. A numeric address that computers recognize eg. `2001:0db8:85a3:0000:0000:8a2e:0370:7334`.",
        },
        [`${prefix}subdomain`]: {
          type: "string",
          label: `${label} - Subdomain`,
          description: "The subdomain for the AAAA record. The third level of the domain name, such as `www` or `ftp`.",
        },
      };
    },
    getCNAMERecordPropDefinitions({
      prefix, label,
    } = {}) {
      return {
        [`${prefix}hostname`]: {
          type: "string",
          label: `${label} - Hostname`,
          description: "The FQDN of the domain that you want to access.",
        },
        [`${prefix}subdomain`]: {
          type: "string",
          label: `${label} - Subdomain`,
          description: "The third level of the domain name, such as `www` or `ftp`.",
        },
      };
    },
    getMXRecordPropDefinitions({
      prefix, label,
    } = {}) {
      return {
        [`${prefix}priority`]: {
          type: "string",
          label: `${label} - Priority`,
          description: "The priority of the target host, lower value means more preferred.",
          optional: true,
        },
        [`${prefix}hostname`]: {
          type: "string",
          label: `${label} - Hostname`,
          description: "The FQDN of the domain that you want to access.",
        },
        [`${prefix}subdomain`]: {
          type: "string",
          label: `${label} - Subdomain`,
          description: "The third level of the domain name, such as `www` or `ftp`.",
        },
      };
    },
    getTXTRecordPropDefinitions({
      prefix, label,
    } = {}) {
      return {
        [`${prefix}subdomain`]: {
          type: "string",
          label: `${label} - Subdomain`,
          description: "The third level of the domain name, such as `www` or `ftp`.",
        },
        [`${prefix}text`]: {
          type: "string",
          label: `${label} - Text`,
          description: "The text content for the TXT record.",
        },
      };
    },
    aRecordPropsMapper(prefix) {
      const {
        [`${prefix}ipAddress`]: ipAddress,
        [`${prefix}subdomain`]: subdomain,
      } = this;
      return {
        dt_assoc: {
          item: [
            ...utils.addItem("subdomain", subdomain),
            ...utils.addItem("ip_address", ipAddress),
          ],
        },
      };
    },
    aaaaRecordPropsMapper(prefix) {
      const {
        [`${prefix}ipv6Address`]: ipv6Address,
        [`${prefix}subdomain`]: subdomain,
      } = this;
      return {
        dt_assoc: {
          item: [
            ...utils.addItem("subdomain", subdomain),
            ...utils.addItem("ipv6_address", ipv6Address),
          ],
        },
      };
    },
    cnameRecordPropsMapper(prefix) {
      const {
        [`${prefix}hostname`]: hostname,
        [`${prefix}subdomain`]: subdomain,
      } = this;
      return {
        dt_assoc: {
          item: [
            ...utils.addItem("subdomain", subdomain),
            ...utils.addItem("hostname", hostname),
          ],
        },
      };
    },
    mxRecordPropsMapper(prefix) {
      const {
        [`${prefix}priority`]: priority,
        [`${prefix}hostname`]: hostname,
        [`${prefix}subdomain`]: subdomain,
      } = this;
      return {
        dt_assoc: {
          item: [
            ...utils.addItem("subdomain", subdomain),
            ...utils.addItem("hostname", hostname),
            ...utils.addItem("priority", priority),
          ],
        },
      };
    },
    txtRecordPropsMapper(prefix) {
      const {
        [`${prefix}subdomain`]: subdomain,
        [`${prefix}text`]: text,
      } = this;
      return {
        dt_assoc: {
          item: [
            ...utils.addItem("subdomain", subdomain),
            ...utils.addItem("text", text),
          ],
        },
      };
    },
    getJsonBody() {
      const {
        domain,
        nameserversOk,
        numberOfARecords,
        numberOfAAAARecords,
        numberOfCNAMERecords,
        numberOfMXRecords,
        numberOfTXTRecords,
        aRecordPropsMapper,
        aaaaRecordPropsMapper,
        cnameRecordPropsMapper,
        mxRecordPropsMapper,
        txtRecordPropsMapper,
      } = this;

      const aRecords = utils.getFieldsProps({
        numberOfFields: numberOfARecords,
        fieldName: "a",
        propsMapper: aRecordPropsMapper,
      });

      const aaaaRecords = utils.getFieldsProps({
        numberOfFields: numberOfAAAARecords,
        fieldName: "aaaa",
        propsMapper: aaaaRecordPropsMapper,
      });

      const cnameRecords = utils.getFieldsProps({
        numberOfFields: numberOfCNAMERecords,
        fieldName: "cname",
        propsMapper: cnameRecordPropsMapper,
      });

      const mxRecords = utils.getFieldsProps({
        numberOfFields: numberOfMXRecords,
        fieldName: "mx",
        propsMapper: mxRecordPropsMapper,
      });

      const txtRecords = utils.getFieldsProps({
        numberOfFields: numberOfTXTRecords,
        fieldName: "txt",
        propsMapper: txtRecordPropsMapper,
      });

      const records = [
        ...aRecords,
        ...aaaaRecords,
        ...cnameRecords,
        ...mxRecords,
        ...txtRecords,
      ];

      return {
        data_block: {
          dt_assoc: {
            item: [
              ...utils.addItem("protocol", constants.PROTOCOL.XCP),
              ...utils.addItem("object", constants.OBJECT_TYPE.DOMAIN),
              ...utils.addItem("action", constants.ACTION_TYPE.SET_DNS_ZONE),
              {
                "@_key": "attributes",
                "dt_assoc": {
                  item: [
                    ...utils.addItem("domain", domain),
                    ...(records.length
                      ? [
                        ...utils.addItem("nameservers_ok", nameserversOk),
                        {
                          "@_key": "records",
                          "dt_assoc": {
                            item: [
                              ...utils.addDnsRecord("A", aRecords),
                              ...utils.addDnsRecord("AAAA", aaaaRecords),
                              ...utils.addDnsRecord("CNAME", cnameRecords),
                              ...utils.addDnsRecord("MX", mxRecords),
                              ...utils.addDnsRecord("TXT", txtRecords),
                            ],
                          },
                        },
                      ]
                      : []
                    ),
                  ],
                },
              },
            ],
          },
        },
      };
    },
    updateDnsRecords(args) {
      return this.app.post(args);
    },
  },
  async run({ $ }) {
    const {
      updateDnsRecords,
      getJsonBody,
      jsonOutput,
    } = this;

    const response = await updateDnsRecords({
      $,
      jsonBody: getJsonBody(),
      jsonOutput,
    });

    $.export("$summary", "Successfully updated DNS records.");
    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.

LabelPropTypeDescription
OpenSRSappappThis component uses the OpenSRS app.
Domaindomainstring

The domain name to register, update, or transfer.

Nameservers OKnameserversOkstringSelect a value from the drop down menu:{ "label": "Domain is not set up to use the OpenSRS nameservers", "value": "0" }{ "label": "Domain is set up to use the OpenSRS nameservers", "value": "1" }
Number of A RecordsnumberOfARecordsinteger

Number of A records to update

Number of AAAA RecordsnumberOfAAAARecordsinteger

Number of AAAA records to update

Number of CNAME RecordsnumberOfCNAMERecordsinteger

Number of CNAME records to update

Number of MX RecordsnumberOfMXRecordsinteger

Number of MX records to update

Number of TXT RecordsnumberOfTXTRecordsinteger

Number of TXT records to update

JSON OutputjsonOutputboolean

Whether to output the response in JSON format.

Action Authentication

OpenSRS uses API keys for authentication. When you connect your OpenSRS account, Pipedream securely stores the keys so you can easily authenticate to OpenSRS APIs in both code and no-code steps.

About OpenSRS

Reseller Platform for Domains, Email, and SSL

More Ways to Connect OpenSRS + Supabase

Other Popular Integrations

Register Domain with OpenSRS API on New Row Added from Supabase API
Supabase + OpenSRS
 
Try it
Register Domain with OpenSRS API on New Webhook Event (Instant) from Supabase API
Supabase + OpenSRS
 
Try it
Update DNS Records with OpenSRS API on New Row Added from Supabase API
Supabase + OpenSRS
 
Try it
Initiate Domain Transfer with OpenSRS API on New Row Added from Supabase API
Supabase + OpenSRS
 
Try it
Initiate Domain Transfer with OpenSRS API on New Webhook Event (Instant) from Supabase API
Supabase + OpenSRS
 
Try it

Popular Triggers

New Row Added from the Supabase API

Emit new event for every new row added in a table. See documentation here

 
Try it
New Webhook Event (Instant) from the Supabase API

Emit new event for every insert, update, or delete operation in a table. This source requires user configuration using the Supabase website. More information in the README. Also see documentation here

 
Try it
New DNS Zone Change from the OpenSRS API

Emit new event when the DNS/ZONE check has passed or failed at the registry. See the documentation

 
Try it
New Domain Registration from the OpenSRS API

Emit new event for each new domain registration. See the documentation

 
Try it
New Transfer Status from the OpenSRS API

Emit new event when the status of a domain transfer changes. See the documentation

 
Try it

Popular Actions

Batch Insert Rows with the Supabase API

Inserts new rows into a database. See the documentation

 
Try it
Delete Row with the Supabase API

Deletes row(s) in a database. See the docs here

 
Try it
Insert Row with the Supabase API

Inserts a new row into a database. See the docs here

 
Try it
Remote Procedure Call with the Supabase API

Call a Postgres function in a database. See the docs here

 
Try it
Select Row with the Supabase API

Selects row(s) in a database. See the docs here

 
Try it

Explore Other Apps

1
-
24
of
2,900+
apps by most popular

Node
Node
Anything you can do with Node.js, you can do in a Pipedream workflow. This includes using most of npm's 400,000+ packages.
Python
Python
Anything you can do in Python can be done in a Pipedream Workflow. This includes using any of the 350,000+ PyPi packages available in your Python powered workflows.
Notion
Notion
Notion is a new tool that blends your everyday work apps into one. It's the all-in-one workspace for you and your team.
OpenAI (ChatGPT)
OpenAI (ChatGPT)
OpenAI is an AI research and deployment company with the mission to ensure that artificial general intelligence benefits all of humanity. They are the makers of popular models like ChatGPT, DALL-E, and Whisper.
Anthropic (Claude)
Anthropic (Claude)
AI research and products that put safety at the frontier. Introducing Claude, a next-generation AI assistant for your tasks, no matter the scale.
Google Sheets
Google Sheets
Use Google Sheets to create and edit online spreadsheets. Get insights together with secure sharing in real-time and from any device.
Telegram
Telegram
Telegram, is a cloud-based, cross-platform, encrypted instant messaging (IM) service.
Google Drive
Google Drive
Google Drive is a file storage and synchronization service which allows you to create and share your work online, and access your documents from anywhere.
HTTP / Webhook
HTTP / Webhook
Get a unique URL where you can send HTTP or webhook requests
Google Calendar
Google Calendar
With Google Calendar, you can quickly schedule meetings and events and get reminders about upcoming activities, so you always know what’s next.
Schedule
Schedule
Trigger workflows on an interval or cron schedule.
Pipedream Utils
Pipedream Utils
Utility functions to use within your Pipedream workflows
Shopify
Shopify
Shopify is a complete commerce platform that lets anyone start, manage, and grow a business. You can use Shopify to build an online store, manage sales, market to customers, and accept payments in digital and physical locations.
Supabase
Supabase
Supabase is an open source Firebase alternative.
MySQL
MySQL
MySQL is an open-source relational database management system.
PostgreSQL
PostgreSQL
PostgreSQL is a free and open-source relational database management system emphasizing extensibility and SQL compliance.
Premium
AWS
AWS
Amazon Web Services (AWS) offers reliable, scalable, and inexpensive cloud computing services.
Premium
Twilio SendGrid
Twilio SendGrid
Send marketing and transactional email through the Twilio SendGrid platform with the Email API, proprietary mail transfer agent, and infrastructure for scalable delivery.
Amazon SES
Amazon SES
Amazon SES is a cloud-based email service provider that can integrate into any application for high volume email automation
Premium
Klaviyo
Klaviyo
Email Marketing and SMS Marketing Platform
Premium
Zendesk
Zendesk
Zendesk is award-winning customer service software trusted by 200K+ customers. Make customers happy via text, mobile, phone, email, live chat, social media.
Premium
ServiceNow
ServiceNow
The smarter way to workflow
Slack
Slack
Slack is the AI-powered platform for work bringing all of your conversations, apps, and customers together in one place. Around the world, Slack is helping businesses of all sizes grow and send productivity through the roof.
Microsoft Teams
Microsoft Teams
Microsoft Teams has communities, events, chats, channels, meetings, storage, tasks, and calendars in one place.
abcdefghijklmnopqrstuvwxyz#
Pipedream, Inc. — San Francisco, CA
AboutTwitterDocsCommunityTermsPrivacyTry String