Resources · Make integration

Xata Make integrationAutomate Xata with Make.

Can Make write to your Xata database without a line of code? Yes: the Xata Make integration gives you 7 action modules to build tables, add or delete records and run SQL batches. This page walks you from the connection to a first working scenario.

Try the Xata integration on MakeSee the 7 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What does the Xata Make integration let you automate?

The Xata Make integration links your Xata database to Make, a no-code tool where you chain apps into a scenario, the automation you build. Each Xata module is one brick of that chain: it creates a table, writes a record, reads one back or runs SQL. Your data reaches Xata without anyone opening a console.

Capture leads straight into a table. A form tool or a CRM fires first, and Create a Record writes each submission as a new row. Every item Make passes along is called a bundle, so one form entry travels as one bundle and lands as one record.

Prepare the structure for a new client. When a project starts, Create a Table followed by Create a Column gives it its own table, shaped the way your product expects, before any data arrives.

Update several tables in one pass. Batch Execute SQL Queries sends several SQL statements at once, handy when a single event should change more than one table. Get a Record reads a row back when you already hold its id.

What it does not do: the Xata app has no trigger, so Make cannot watch Xata for new records; the scenario starts from another app or from a schedule. Make also flags its Xata documentation as AI-generated, so check important details against Xata's own docs. If you run n8n too, the Xata n8n integration covers the same database, and n8n vs Make lays out how the two tools differ. New to the editor? Make training starts from zero.

Connect

How do you connect Xata to Make?

  1. 01

    Grab your API key and endpoint

    In Xata, open your account settings, click Add a key, give it a name, click Save and copy the key shown in the window. Then go to Workspaces, open your database and copy the database endpoint from its Settings page.

  2. 02

    Add a Xata module in Make

    In your scenario, add any Xata module and click Create a connection. A connection is your Xata account linked to Make once, then reused by every Xata module. The Connection name field is optional, but a clear name helps you recognize it later.

  3. 03

    Paste your credentials

    Paste the API key and the database endpoint you copied, or follow the on-screen instructions, then save. The connection now shows up in the module, ready for every other Xata module you add to this scenario or the next one.

First scenario

Your first scenario: save form entries to Xata

GoalWhen someone submits a form in another app, Make creates a record in your Xata table.

  1. 01

    Create the scenario

    On the Scenarios page, create a new scenario and click the + to add the first module. Here it is the trigger of the app that collects your entries, such as your form tool.

  2. 02

    Add Create a Record

    Click the + on the right of that first module, search for Xata and pick Create a Record. Select your connection, or create it with the three steps above.

  3. 03

    Map the form answers

    Fill the module fields by mapping values from the first module, one answer of the form per field. Each bundle that arrives will become one record in your table.

  4. 04

    Test with Run once

    Click Run once, submit a test entry, then open the bundles each module received. Check that the new record really sits in Xata before going further.

  5. 05

    Schedule and switch on

    Set the schedule on the first module, every 15 minutes by default, and switch the scenario on. Each run uses operations, one per module and per bundle, which is what Make counts on your plan.

Modules

What each Xata module does

Xata gives you 7 modules. For each one: what it does for you, when to reach for it, and what to watch out for.

Xata1

Batch Execute SQL Queries

Action

In Make“Executes multiple SQL queries across the database branch.”

Sends several SQL queries to your database branch from a single module, so one event can update, insert or clean data across tables without chaining one module per query.

When to use it
an order is cancelled and three tables need to reflect it at the same time.
Watch out
the queries run exactly as you wrote them, so try them with Run once on test data before the scenario goes live.
Xata2

Create a Column

Action

In Make“Creates a column inside a table.”

Adds a column to an existing table, which lets your scenario grow the schema when a new kind of data shows up instead of someone editing the table by hand.

When to use it
right after Create a Table, to give a fresh table the columns your records will need.
Watch out
place it where it runs once per table, not on every bundle that flows through the scenario.
Xata3

Create a Record

Action

In Make“Creates a record in a table.”

Writes a new row into a Xata table from data coming out of another app, which is how most scenarios feed the database.

When to use it
a signup, an order or a support ticket should end up as a record you can query later.
Watch out
it creates one record per bundle received, so a Run once test adds real rows; remove them afterwards if they clutter the table.
Xata4

Create a Table

Action

In Make“Creates a table.”

Builds a brand new table in your database, so a scenario can prepare storage on its own rather than waiting for someone to click through Xata.

When to use it
each new client or project gets its own table the moment the deal is signed.
Watch out
an empty table does little by itself; follow it with Create a Column so records have somewhere to go.
Xata5

Delete a Record

Action

In Make“Deletes a record from a table.”

Removes a record from a table, keeping Xata in step when something is deleted or cancelled in another tool.

When to use it
a customer asks to be erased, or a draft entry gets rejected and should not stay in your data.
Watch out
check which id reaches this module before you switch it on, and test it with Run once on a record you can afford to lose.
Xata6

Get a Record

Action

In Make“Retrieves a record by its id.”

Fetches one record when you already know its id and hands its values to the next modules as a bundle, ready to drop into an email or a document.

When to use it
the event that starts the scenario carries the id, and you need the details stored in Xata.
Watch out
it looks up by id only; without that id, this module has nothing to fetch.
Xata7

Make an API Call

Action

In Make“Performs an arbitrary authorized API call.”

Calls any endpoint of the Xata API with the connection you already set up, which covers whatever the six other modules leave out.

When to use it
Xata offers an operation that no listed module handles and your scenario needs it.
Watch out
you write the request yourself, so keep the Xata API reference open while you build and test it with Run once.
Need help

Need help automating Xata with Make?

A person reads every message.

FAQ

Xata and Make: common questions

01Is the Xata Make integration free?
Yes, on the Make side. Xata is a standard app, available from the Free plan onward. That plan allows 2 active scenarios, at least 15 minutes between two scheduled runs, 5 minutes per execution and 512 MB of data transfer. Paid plans (Core, Pro, Teams and Enterprise) bring the interval down to 1 minute and count usage in credits per month. On the Xata side, you still need an active account and an API key, and Xata's own pricing page covers its subscription.
02What do you need to connect Xata to Make?
An active Xata account, an API key and your database endpoint. You create the key in your Xata account settings with Add a key, give it a name, save it and copy it. The endpoint sits on the Settings page of the database, reached through Workspaces. In Make, add any Xata module, click Create a connection, name it if you like and paste both values. That single connection then serves all 7 Xata modules in every scenario you build.
03Does Xata trigger Make scenarios in real time?
No, because the Xata app in Make has no trigger at all. Make cannot watch a table for new records, so the scenario has to start somewhere else. You can open it with a trigger from another app, the tool where your data first appears, or rely on scheduling, the clock on the first module, which runs a new scenario every 15 minutes by default. The Free plan keeps that interval at 15 minutes minimum, paid plans go down to 1 minute. If the other app has an instant trigger, it calls Make through a webhook as soon as something happens.
04What if a Xata module is missing in Make?
Use Make an API Call. It reaches any endpoint of the Xata API with the connection you already have, so whatever the six other modules do not cover stays within reach. You write the request yourself, so keep the Xata API reference nearby while you build it. Also note that Make labels its Xata documentation as AI-generated and warns it may contain mistakes, so confirm important behavior in Xata's own docs before a scenario touches production data.
05Should you use Make or n8n for Xata?
It depends on the tool your team already works in, since Xata can be automated from both. In Make, you get 7 modules, from table creation to SQL batches, plus Make an API Call for anything else, and you can start on the Free plan with 2 active scenarios. n8n also offers a Xata node, covered on its own page of this site. No winner is declared here: look at the scenarios you plan to build and pick the tool your team will actually maintain.
Same platform

Other docs you might need on this stack.

Browse all integrations