` element on top of the document `` that stores application id and page id on it’s `data-appid` and `data-pageid` attributes.
- If there is a logged in user `window.logged_in_user` object is available with `softr_user_email` , `softr_user_full_name` properties. If you have synced your users table with a data source, you will also be able to access the other properties about the user as well.
- Block specific data is stored on `window` object with `hrid` as an identifier of that block. (ex. `window['table1']` in case hrid is table1).
The `window[hrid]` object differs based on block type.
- List, List details, Kanban, Chart, Organization chart, Calendar, Twitter and Map blocks have `baseId` and `tableName` properties.
- Form block has `airtableBaseUrl` property
- Map block has `google_map_api_key` property
- There is `openSwModal` global method that opens given url in modal.
Example: `openSwModal('https://softr.io/')`
## Charts
### Chart colors
To change chart default colors we should set
```javascript
window['chart1-colors'] = ['#FE8070', '#DD7E6B', '#EA9999', '#F4CCCC', '#24A37D', '#AEAEB5', '#E25B5B', '#FFF974', '#4BAEAE', '#E5E5EA', '#33E4EF', '#C9DAF2'];
```
where `chart1` is the block hrid.
### Chart invalidate
Invalidate the chart cache after 5 seconds:
```javascript
```
where `chart1` is the block hrid.
### Chart reload
Reload after 5 seconds:
```javascript
```
where `chart1` is the block hrid.
### Chart invalidate and reload
Invalidate the cache and reload the chart:
```javascript
```
Where `chart1` is the block hrid
### **Chart v5 change colors depending on value WIP**
```javascript
```
## Browser Events
Adding **event listeners** to **elements** that were rendered by **React** is tricky.
You may **add** an **event listener** but after **React re-renders** the **component** it might **loose** your **listener** because React can (in some cases) remove and re-create element that you added the listener on.
To handle this the `event listener` should be added on `parent element` that doesn’t re-render and `check` the element `selector` after `event trigger`.
Example:
```javascript
const handler = (e) => {
if (e.target.closest('#table1 .ag-row')) {
// handle click event on ag-row
}
};
document.body.addEventListener('click', handler);
```
This way you can handle `click` event on table rows with `table1` hrid.
## Generic Custom Events
There are custom events that Softr blocks trigger or listen to.
We also add **hrid** to the event name to identify the block the event refers to.
### **block-loaded**
`block-loaded` event is triggered when React mounts the block into DOM. It can be used instead of `DOMContentLoaded` event that is used in old custom codes.
ex.
```javascript
window.addEventListener('block-loaded-table1', () => {
console.log('Block loaded');
});
```
### **get-record**
`get-record` event is triggered on every single data response from softr data service. It is used on list-details blocks and it can be used as for getting the data and using it for other 3rd party calls or as a indicator that after some small interval time the block will be fully rendered.
ex.
```javascript
const onRecord = (e) => {
// we got new data under e.details
console.log(e.detail);
//console.log {id: '***', fields: {...}}
};
window.addEventListener('get-record-list-details1', onRecord);
```
```javascript
const onRecord = (e) => {
setTimeout(() => {
// The block finish rendering
// I may do some staff here.
}, 50);
};
window.addEventListener('get-record-list-details1', onRecord);
```
```javascript
window.addEventListener('get-record-list-details1', (e) => {
// hide list details block if no record found
if (!e.detail.id) {
document.getElementById('list-details1').classList.add('d-none');
}
});
```
### **get-records**
`get-records` event is triggered on every data response from softr data service. It can be used as for getting the data and using it for other 3rd party calls or as a indicator that after some small interval time the block will be fully rendered.
ex.
```javascript
const onRecords = (e) => {
// we got new data under e.details
console.log(e.detail);
//console.log [{id: '***', fields: {...}}]
};
window.addEventListener('get-records-table1', onRecords);
```
```javascript
const onRecords = (e) => {
setTimeout(() => {
// The block finish rendering
// I may do some staff here.
}, 50);
};
window.addEventListener('get-records-table1', onRecords);
```
Also there is an `get-records:before` event that is triggered before sending request, It can be used to catch the inline filter or search field changes.
```javascript
const onFilterChange = (e) => {
console.log(e.detail);
//console.log { search: '', filter: [ { field: 'size', value: 'M' } ] }
};
window.addEventListener('get-records-table1:before', onFilterChange);
```
### **update-records**
`update-records` event is listened by all blocks that use external data.
It can be used to change/add/remove the data that should be rendered. Mostly it can be used in pair with `get-records`.
ex.
```javascript
const onRecords = (e) => {
const modifiedRecords = e.detail.map(({fields, ...other}) => ({
...other,
fields: {
...fields,
phone: fields.phone ? fields.phone.replace('+374', '0') : '',
}
}));
const modify = new CustomEvent('update-records-table1', { detail: modifiedRecords });
setTimeout(() => window.dispatchEvent(modify), 1);
};
window.addEventListener('get-records-table1', onRecords);
```
## Action Buttons
### **add-record**
`add-record-hrid` event is fired when the form submission in the add-record modal is triggered.
`add-record-success-hrid` event is fired when the submission is successful
`add-record-failure-hrid` event is fired when the submission has failed
```
```
### update-record
`update-record-success` event with field values is triggered after getting response with success status code.
`update-record-failure` event is triggered after getting response with error code.
ex.
```javascript
window.addEventListener('update-record-failure-list1', (e) => {
console.log('update record failure', e.detail);
// update record failure 'Email field is required.'
});
// To reload the page after record update on #list1 block
window.addEventListener('update-record-success-list1', () => {
window.location.reload()
});
```
### upvote-record
`upvote-record-success` event with field values is triggered after getting response with success status code and datail.
`upvote-record-failure` event is triggered after getting response with error code.
ex.
```javascript
```
### call-api (webhook-trigger)
`call-api-success` event with field values is triggered after getting response with a success status code.
`call-api-failure` event is triggered after getting response with error code.
ex.
```javascript
```
## Blocks Custom events
### Calendar block trigger reload block
ex.
```javascript
```
### List blocks trigger reload block
ex.
```javascript
```
## Form Custom Events
### **update-fields**
`update-fields` event is listened by blocks that use form inputs with Formik library. Currently it’s blocks under Form and User Accounts categories. It can be used to update input values with custom code. This is used to update form values from a code automatically… let’s say after form is rendered client side custom code fetches a data from third party API and wants to set into form to be submitted… (keep in mind user attributes and URL attributes can be prefilled with default functionality without code)
ex.
```javascript
```
### **submit-form, submit-form-success, submit-form-failure**
`submit-form` event with field values as an attribute is triggered before sending form submission request.
`submit-form-success` event with field values is triggered after getting response with success status code.
`submit-form-failure` event is triggered after getting response with error code.
ex.
```javascript
window.addEventListener('submit-form-form1', (e) => {
// e.detail is an object with form field names and values
console.log('form submit', e.detail);
// form submit { "Full Name": "Softr", "Email": "info@softr.io" }
});
window.addEventListener('submit-form-success-form1', (e) => {
// e.detail is an object with form field names and values
console.log('form submit success', e.detail);
// form submit success {
// payload: { "Full Name": "Softr" ... },
// response: { headers: {...}, data: {...}, status: 200 }
// }
});
window.addEventListener('submit-form-failure-form1', (e) => {
console.log('form submit failure', e.detail);
// form submit failure 'Email field is required.'
});
```
### **Customize form’s validation messages**
Make error massages of inputs in forms and user account blocks changeable/translatable via a custom code:
```
```
## Header Custom Events
### set-logo-link
`set-logo-link` event is used to set header logo link to custom url.
ex.
```javascript
window.addEventListener('block-loaded-header1', () => {
const detail = { link: 'https://google.com' };
window.dispatchEvent(new CustomEvent('set-logo-link-header1', { detail }));
});
```
### trigger action before logout
first will trigger custom action and after 300 ms will continue to Sign Out
ex.
```javascript
window.addEventListener('user-sign-out', (e) => {
// do some actions before logout - (300 ms)
});
```
### Sign-out user by clicking on custom button
`block-loaded` event is triggered when React mounts the block into DOM.
ex.
```javascript
```
## Tab Container Custom Events
`tab-selected` event is triggered every time the user selects a new tab in the Tab Container.
The event is triggered only when the active tab is changed, if the user clicks on the already active tab the event won’t be triggered.
ex.
```javascript
// Add an event listener for "tab-selected" event for Tab container with "tab-container1" id
window.addEventListener('tab-selected-tab-container1', (e) => {
// the selected tab id is stored in e.details
console.log(e.detail);
});
```
## Styling
There is still bootstrap included in the page, but it will be removed in the near future. So try not to use it.
Material-ui React component library is used in the new blocks. It adds classes to all small to large components with the prefix of `Mui` those classes can be used to add custom styles to the elements, but we may also change it to `Softr` or something similar in the near future (ex. `MuiInputBase` to `SoftrInputBase`).
Try wrapping selector with hrid to add more priority to your selector.
ex.
```css
#table1 .MuiInputBase-input {
border-left: none;
}
```
There are also some attributes that expose the content of the element. It can help identify and style them based on it.
- data-content attribute on tag elements
- data-rating attribute on rating elements
Because CSS supports attribute selectors, they can be used to style the elements based on content.
ex.
```css
// tags with content "Low"
#table1 .tag-item[data-content="Low"] {
background-color: #F00 !important;
}
// add span to the selector if you want to customize text color
#table1 .tag-item[data-content="Low"] span {
color: #FFF !important;
}
// tags that start with word "Low"
#table1 .tag-item[data-content^="Low"] {
background-color: #F00 !important;
}
// tags that have substring "low"
#table1 .tag-item[data-content*="low"] {
background-color: #F00 !important;
}
// ratings that are 1 start
#table1 [data-rating="1"] span {
color: #F00 !important;
}
```
### Overriding navigation styles
```css
```
### Kanban block custom column background colors
ex.
```javascript
```
### Styles and actions for Action buttons by custom code
ex.
```javascript
// ✅ get an element with data-action-button-id
const el1 = document.querySelector('[data-action-button-id="list1-visible-btn-0-rec1yIahkX1mZhLQn"]');
// ✅ get an element where data-action-button-id starts with list1-visible-btn or list1-btn
const el1 = document.querySelector('[data-action-button-id^="list1-visible-btn-"]');
// ✅ get all elements where data-action-button-id starts with list1-visible-btn
const elements = document.querySelectorAll('[data-action-button-id^="list1-visible-btn-"]');
#list2 button[data-action-button-id^="list2-visible-btn-_l26zaezue"] {
margin-left: 50px
}
```
```css
// ✅ style for all buttons where data-action-button-id starts with list1-visible-btn-
#list1 button[data-action-button-id^="list1-visible-btn-"] {
margin-left: 50px
}
// ✅ style for one of buttons with data-action-button-id-BUTTONID
#list1 button[data-action-button-id^="list1-visible-btn-_l26zaezue"] {
margin-left: 50px
}
```
### Selectors available for styling using custom code
Various CSS classes and `data-` attributes let you style UI elements and select them with JavaScript.
Class names use the `.softr-` prefix to distinguish them from internal classes that may change.
Similarly, stable `data-*` attributes use the `data-softr-*` prefix, with a few exceptions like `data-action-id`.
```css
/**
* Grid block's card container. Can be used to adjust the gap
* between the cards using the `gap` property
*/
#list1 .softr-grid-container {
gap: 24px;
}
/**
* Similar to `softr-grid-container` but for the list block
*/
#list1 .softr-list-container {}
/**
* Container for all fields in the list and list details blocks
*/
#list1 .softr-fields-container {}
/* Field labels for list and list details blocks */
#list1 .softr-field-label {}
/* The wrapping element for each field/modal field input has this attribute */
#list1 [data-softr-field-id='your-field-id'] {
/* Selects the wrapper div for the field with id 'your-field-id'.
You can find the field id from the browser dev tools.
*/
}
/* Various dialog containers */
#list1 [data-softr-dialog-type] {
/* Selects all dialogs in the list1 block */
}
#list1 [data-softr-dialog-type='UPDATE_RECORD'] {
/* Selects only the `Update record` dialog in list1 block */
}
```
### Worked out example for styling form inputs
Let's see how to customize the appearance of input fields in the "Add record" form.
Here's the end result:
```css
```
---
# SPA Custom Code Guidelines
Source: https://docs.softr.io/custom-code/spa-custom-code-guidelines
In the SPA mode, custom code works a little differently than non SPA mode. Since we never do full page reload in the SPA mode, page level custom code needs to ensure that it doesn’t interfere with other pages.
## TL;DR
- Keep page specific code out of app level custom code.
- Whenever possible, use plain HTML/CSS instead of Javascript.
- Use `
```
## Cleanup timers and resize observers on page unload
If your page custom code sets up timers or resize observers, they need to be cleaned up before the page unloads. This ensures that the timers don’t keep running after navigating away from the page.
For example, here’s a custom code block which shows the number of seconds this page has been open for
```text
The page has been open for
0 second(s)
```
## Don’t use DOMContentLoaded in page level custom code
DOMContentLoaded will only fire once, on app load. Navigating between the pages will **not** re-run the event listener.
Instead, `window.SOFTR_PAGE.waitFor` provides a simple way to wait for an element to be on the page before continuing.
```text
```
---
# Open AI
Source: https://docs.softr.io/integrations/open-ai
Now you can generate images and copy with the help of [Open AI](https://openai.com/) to really speed up the app creation process. Moreover, you can create apps that offer AI functionality to your users (like [copy.ai](http://copy.ai/) or [jasper.ai](http://jasper.ai/)). Read on to learn more.
> **Tip**
>
> The feature is available **on all subscription plans** including the Free plan.
## **Generating content for your Softr app**
Whenever adding an image to a block in your Softr app, you can use the Asset Generator to generate an image for you. The following videos show how that works.
Similarly, on any text field you have the option of adding AI-generated copy by providing a helpful prompt. The video below illustrates the process.
## **Allowing your users to generate content**
You can also allow your users to generate images and copy using the AI Dynamic Blocks. Just add one of the blocks to your app and make the magic available to your users. To make this happen, you first need to integrate with Open AI, which we’ll discuss in a bit.
## Sending custom prompts to OpenAI
Want to take one step further? Check out Softr Community member Dominic's video on how to integrate GPT-3 with Softr.
## Integrating with Open AI
To integrate Open AI with your Softr app, you need to go to
and sign up. Next, under your account dropdown, select **View API keys**.
_View API keys_
Hit **Create new secret key** and copy the generated key.
_Create new secret key_
Lastly, in your Softr app, navigate to **Settings ⇒ Integrations ⇒ Open Ai**, add the key, and save your settings.Now, you can start adding AI blocks to your application.
When you register on Open AI, you automatically enter a free trial, so, as soon as a user submits the first request (e.g. generates a text using the block), you’ll see your Open AI credit balance under **Usage**.
_Open AI Usage_
You’ll spend credits on each new user request, so, as soon as all the free trial credits expire, you’ll need to Upgrade your Open AI subscription in order to receive more credits.
---
# Google Sign-in
Source: https://docs.softr.io/integrations/google-sign-in
Google Sign-in puts a **Continue with Google** button on your app's sign-in and sign-up forms. People who already have a Google account get in with one click, and you never hold a password for them.
Setting it up happens in two places: you create an OAuth client in the Google Cloud console, then paste its client ID and secret into Softr. Keep both tabs open — you will be moving between them.
> **Note**
>
> Google Sign-in is one of the methods on the [sign-in form](/add-and-manage-users/signin-form), alongside email and password. It is not the same as [SSO](/add-and-manage-users/single-sign-on-overview), which hands authentication to your own identity provider over SAML or OpenID. You can switch both on at once.
## Before you start
**A Google account that can create Cloud projects**
Creating a project needs the `resourcemanager.projects.create` permission. Personal Google accounts have it; a work account in a Google Cloud organization often does not, and the **No organization** row in the project picker will be marked with a warning triangle. If that happens, ask whoever administers your Google Cloud organization to create the project — or to grant you the permission — and carry on from step 2.
**Your app's URL, exactly as visitors see it**
Open your published app and copy the address out of the browser bar. On a Softr subdomain that is `https://yourapp.softr.app`, with no `www.`; on a [custom domain](/publishing/add-a-custom-domain-to-your-app) it is whatever host you connected. You need the scheme and host only — no trailing slash, no path.
## Create your Google OAuth client
1. **Create a Google Cloud project**
In the [Google Cloud console](https://console.cloud.google.com/projectcreate), give the project a name. Google derives a project ID from it, which cannot be changed later. If your account belongs to an organization you also have to pick a **Parent resource**. Click **Create**.
_Naming a new project in the Google Cloud console._
> **Tip**
>
> Already have a project for this app? Skip this step and pick it from the project picker in the console's top bar instead.
2. **Name the app people will consent to**
Go to **Google Auth Platform → Branding**. **App name** and **User support email** are what people see on Google's consent screen the first time they sign in, so use the name of your portal rather than the project ID. Click **Save**.
_App name and support email on the Branding page._
> **Note**
>
> On a brand-new project, opening Google Auth Platform starts a short **Get started** wizard that asks for the app name, support email, audience and a contact address in one pass. Complete it and you arrive at these pages with the work already done. Google documents the rest of the branding options in [Manage OAuth App Branding](https://support.google.com/cloud/answer/15549049).
3. **Choose who can sign in — and publish the app**
Open **Audience**. Two settings on this page decide who gets in.
_Publishing status and user type on the Audience page._
1. **Publishing status.** A new project starts in **Testing**, and while it is in Testing only the Google accounts listed under **Test users** can sign in — up to 100 of them. Click **Publish app** to move it into production.
2. **User type.** **External** lets anyone with a Google account sign in. **Internal** appears only if your Google account belongs to a Google Workspace organization, and limits sign-in to that organization.
> **Warning**
>
> Leaving the project in **Testing** is the most common reason a correctly configured Google Sign-in still fails: everyone who is not on the test-user list is refused. Publish the app before you point real users at it. Google's [Manage App Audience](https://support.google.com/cloud/answer/15549945) covers the limits in full.
Note which **User type** you picked. You set the same value on the Softr side.
4. **Create the OAuth client**
Go to **Clients → Create client**. Set **Application type** to **Web application** and give the client a name. The name is only used to identify the client in the console; nobody signing in ever sees it.
_Choosing the Web application client type._
5. **Add your app's URL to both lists**
Under **Authorized JavaScript origins**, click **Add URI** and paste your app's URL. Then do the same under **Authorized redirect URIs**. Click **Create**.
_The same app URL added as a JavaScript origin and a redirect URI._
> **Note**
>
> Match the origin your visitors actually load, character for character. A Softr subdomain has no `www.` — `https://acme-portal.softr.app`, not `https://www.acme-portal.softr.app`, which does not resolve. On a custom domain, include `www.` only if that is the host people land on.
> **Tip**
>
> Google registers the domains of these URIs as **Authorized domains** on your consent screen automatically, so there is no separate step for that. Changes to a client can take anywhere from five minutes to a few hours to take effect.
6. **Copy the client ID and secret**
Google shows the new client's ID and secret as soon as it is created. Copy both before you close the panel.
> **Warning**
>
> Google no longer lets you view a client secret after creation — the client's page shows only its last four characters. If you lose it, open the client and use **Add secret** to issue a new one, then update Softr with the new value.
## Add the credentials to Softr
1. **Switch Google Sign-in on**
In Softr Studio, open your app and go to **Users → Authentication**. Turn on the **Google Sign-in** toggle (1), then click the gear (2) to open its settings.
_The Google Sign-in row in the Authentication method list._
> **Note**
>
> An amber dot next to a method means **Setup is incomplete** — it is switched on but has no working configuration yet. It clears once you save valid credentials.
2. **Paste the credentials**
Paste the **Google client ID** and **Google client secret** you copied from the console (1). Then set **User type** (2) to the same value you chose on the Audience page.
_The Google Sign-in settings dialog with Internal selected._
With **Internal**, a **Google Sign-in email domains** field appears. Anyone whose email address is on one of these domains is always sent to Google to log in, even when your app also offers email or SSO. Choosing **External** hides the field, because an external client accepts any Google account.
_With External selected, the email domains field is not shown._
3. **Save and publish**
Click **Save**, then publish your app so the change reaches the live site. The amber dot beside **Google Sign-in** should disappear.
## What people see
**Continue with Google** appears above the email field on both the sign-in and the [sign-up form](/add-and-manage-users/signup-form). The first time someone uses it, Google shows a consent screen carrying the app name and support email you set under **Branding**.
_The Continue with Google button on a published app's login page._
Signing in this way creates or matches a record in your app's [users list](/add-and-manage-users/users-menu) on the email address the Google account carries.
## Troubleshooting
**Google refuses the request before showing the account chooser**
The URL registered on the OAuth client does not match the address the browser is on. Compare them character for character: `http` against `https`, `www.` present or absent, and no trailing slash. If you have just changed the client, give it a few minutes — Google warns that client changes can take up to a few hours to propagate.
**Some people can sign in and others cannot**
Either the Google Cloud project is still in **Testing**, in which case only the accounts on the test-user list are allowed, or the client's **User type** is **Internal** and the people being refused are outside your Google Workspace organization. Both live on the **Audience** page.
**The amber dot beside Google Sign-in will not clear**
Softr marks a method **Setup is incomplete** until it has a client ID and secret saved. Reopen the gear and check both fields are filled and saved.
**Only people on certain domains are sent to Google**
That is the **Google Sign-in email domains** field doing its job. Clear it if you want those people to be able to use email or SSO as well.
## Related
[**Sign-in form**](/add-and-manage-users/signin-form)
Every authentication method your app can offer, and how the form behaves.
[**Single Sign-on Overview**](/add-and-manage-users/single-sign-on-overview)
SAML and OpenID, for when authentication should sit with your own identity provider.
[**Internal vs external users**](/add-and-manage-users/internal-vs-external-users)
How Softr counts the people who sign in to your app.
[**Google: set up OAuth 2.0**](https://support.google.com/cloud/answer/15549257)
Google's own reference for OAuth clients, consent and credentials.
---
# Make
Source: https://docs.softr.io/integrations/make
## "Send to Make" Action
The Make integration is available through a **Send to Make** action, which is available as a [Form](/4876cbed455842aebe38e0612d2da96e) submit button action. When you create a form, set the destination of the form response to be Make.
_“Send to Make” action_
After selecting Make from the dropdown, another field will appear where you will place a Make Webhook URL. More on that below:
_Custom Webhook URL field_
Here, you need to fill in a **Custom Webhook URL** to connect to Make. So, let's switch to Make to configure our automation and get the **Webhook URL**.
## Creating a Scenario in Make
In your Make account, you should create a new **Scenario**, set up a **Webhooks** app, and choose the **Custom Webhook** trigger. As soon as the **Custom Webhook** is ready, you need to hit **Copy address to clipboard** to get the **Webhook URL**. Below you can see how that's done.
_Setting up a Custom Webhook trigger and getting its URL_
## Adding the Webhook URL in Form Settings
Now, you need to run your Make scenario and go back to your Softr form to enter the **Webhook URL**. After entering the URL, use the link below to **Send test data**. Further on, if you go back to your Make scenario, you should see a notification on top of your webhook icon. Click on it to see the content of the bundle that has been received. If your test data has arrived successfully, you can now add new modules to your webhook to receive the data on other services.
_Adding the URL and testing the integration_
> **Warning**
>
> IMPORTANT: When sending a test call to the webhook from Softr Studio, not all fields will be sent from the Softr form to the Webhook - only some test fields will be sent. In order for Make to properly identify the correct data structure you will use in production, you should submit a form response from the live app or app preview while the webhook is listening.
## Sending Data to Trello
Now, you need to connect another service to send the data to. Let's assume you've set up a simple contact form and want to send the form submissions to the [Trello](https://trello.com/) task management tool, creating a new card on the board for each submission.
_A simple contact form_
Therefore, you need to click **Add another module** on your custom webhook and search for **Trello** within the new module.
_Adding a Trello module_
Configuring Trello Account and Mapping the Fields
After selecting Trello in the list, scroll down and choose **Create a Card** action.
_“Create a Card” action for Trello_
In the next step, you need to connect your Trello account, clicking the **Add** button under **Connection**. Afterwards, under **Enter a List ID** you can either enter your Trello **List ID** manually or choose **Select** to be provided with the list of your current boards and their lists to choose from.
_Connecting Trello account and board/list_
After setting the board and list you want the cards to be created on, you need to scroll down and map the form fields. In the example below, we've mapped the **Email** field to the card **Name**, and the form **Name** and **Message** fields to the card's **Description**.
_Mapping form fields to Trello_
## Testing the integration
That's it. Now, let's run our Scenario and do a test submission from our Softr form to make sure the data is being received on Trello.
_Testing the Automation_
> **Tip**
>
> Note: When sending a test call to the webhook from Softr Studio, not all fields will be sent from the Softr form to the Webhook - only some test fields will be sent. In order for Make to properly identify the correct data structure you will use in production, you should submit a form response from the live app or app preview while the Webhook is listening.
---
# Zapier
Source: https://docs.softr.io/integrations/zapier
## "Send to Zapier" Action
The Zapier integration is available through a **Send to Zapier** action, which can be selected for the [form](/4876cbed455842aebe38e0612d2da96e) submission button.
After selecting the action, a field titled **Zapier** will appear below. Here, you will need to add the **custom webhook URL**, which we’ll discuss shortly.
_Custom webhook URL_
> **Tip**
>
> Please, note that if you have a **File** field in your form, the attached file(s) won't be transferred to Zapier. As a workaround, we'd suggest using links (e.g. a Google Drive link) for sending files.
## Creating a ZAP
Next, you need to go to your Zapier account and hit the **MAKE A ZAP** button in the upper left corner.
_“Make a Zap” button_
In the app event search bar, look for the **Webhooks by Zapier** app and select it.
_Locating “Webhooks by Zapier”_
Then, select **Catch Hook** as a **Trigger Event** and hit **Continue**.
_“Catch Hook” trigger event_
In the following step, you’ll get a **Custom Webhook URL**, which you need to copy and add it back in the Zapier field of your button action.
_Getting Custom Webhook URL_
## Entering the URL back in Softr Studio
Navigate back to Softr Studio, enter the copied URL as a value in the Zapier field.
_Entering Custom Webhook URL_
Now, you can click to send test data to make sure it's working.
_Sending test data_
## Checking the Results in Zapier
After sending test data, go back to your Zap setup and proceed to the next step. There you should see a **Test trigger** button.
_Testing the trigger_
If after hitting the button your request is found, as shown in the screenshot below, then the integration has been successful, and the only thing left is to click **Continue** to go to the next step in your Zap setup and configure the application to which you want your data to be sent to.
_Test trigger success_
## Sending Data to Google Sheets
In the next step, you need to define the action that the zap needs to accomplish. Let's assume, we want to send the form data to Google Sheets, creating a new row within the sheet for every submission. If for instance, we use the Simple Contact Form, we should have corresponding columns in the sheet to map the fields.
_A contact form on Softr_
_Corresponding fields on Google Sheets_
So, in the next **Action** step, we need to choose the Google Sheets app, set **Create Spreadsheet Row** as an **Action Event**, and hit Continue.
_Selecting Google Sheets under Action_
_Choosing an event_
In the next step, you need to add your Google account (if it hasn't been added yet) to get access to Google Sheets.
_Connecting Google Sheets account_
In the next step, you need to add the Google drive where your spreadsheet is located, and select the spreadsheet and worksheet you want to send the data to. Lastly, you need to map the form fields to the corresponding worksheet columns, as shown below.
_Adding Google Sheets details_
## Testing the integration
Proceed to the next step, and you're almost done. You just need to test the action to make sure it's working correctly.
_Running a test automation_
If the test was successful, you should see a success message in the next step and your spreadsheet should be updated with the test data, as shown below.
_Test submission received_
The form is now linked to the spreadsheet and you can start receiving submissions.
---
# Iubenda Cookie Solution
Source: https://docs.softr.io/integrations/iubenda-cookie-solution
Iubenda Cookie Solution allows to add a customizable cookie consent banner on your site. You will need an Iubenda subscription for this integration. Let's see how it can be done.
> **Tip**
>
> By default, Iubenda will block the most common scripts on your site until the user hits **Accept**. More details on privacy controls and cookie solution configuration are available [here](https://www.iubenda.com/en/help/1205-how-to-configure-your-cookie-solution-advanced-guide).
## Generating a Banner
In your Iubenda account home page, click the **Start Generating** button.
_Start generating_
Choose the **Website** option, specify a **Site Name**, and hit **Start Generating**.
_Choosing the “Website” option_
Next, locate the **Cookie Solution** option and click **Generate Now**.
_Generating the code_
In the following page, you can customize your banner's design and configure other settings. Hit **Next** as soon as you're done.
_Customizing the banner design_
Next, if you don't have a paid license, you'll see a pop-up with the upgrade options. You don't need a paid license for the cookie solution, so, if you don't want to upgrade at this point, simply close the pop-up.
_Closing the upgrade pop-up_
## Getting the Banner Code
Now, you should see an **Embed** button under **Cookie Solution**. Click the button to get the banner code.
_Getting the embed code_
Here, you can enable/disable **Prior blocking and asynchronous re-activation** and customize the banner further if needed. When everything is ready, simply click **Copy** to copy the banner code.
_Accessing the embed code and customizing the banner further_
## Adding the Banner Code in Softr Studio
Now, switch to your Softr Studio, navigate to **Settings => Integrations => Iubenda Cookie Solution,** and paste the code.
_Applying banner code in Softr_
You're almost done. Just save the settings and republish your app, and you'll notice the cookie consent banner appearing.
_Iubenda pop-up published on the Softr app_
---
# Documint
Source: https://docs.softr.io/integrations/documint
With Softr x Documint integration, you can generate documents directly from your dynamic blocks connected to [Airtable](/data-sources/1YYStCJukT15Lh2j93qo9A/airtable/jHX7kfH7QvkVcELQvS3VoX). For more info, please visit [this page](https://docs.documint.me/integrations/softr).
---
# Mailchimp
Source: https://docs.softr.io/integrations/mailchimp
Using Mailchimp you can collect email addresses from your audience, who fill out email capture forms on your website. All email addresses will be sent to and stored in your Mailchimp account.
## **Configuration**
When you use a building block with email capture form (e.g. [Hero section with email capture](/59b829b4b58f417fa4b6cff5f7c6a658)), you will see the following options in the sidebar to choose from.
_List of action options_
Choose the **Add to Mailchimp** option to collect emails via Mailchimp. After selection, you will see the **Action Url** field appear.
_Mailchimp action URL_
You need to locate the **Action Url** from your Mailchimp account, and copy paste it in this field.
## **How to locate Mailchimp Form Action Url**
In order to get an Action URL and start collecting subscriptions, you need to log into your Mailchimp account and navigate to **Signup Forms ⇒ Embedded Forms**.
_Embedded forms_
The embedded form will only have the email field enabled by default, so, if you’re just collecting emails, you don’t need to change anything (we’ll discuss setting up forms with multiple fields in the next section). Just hit **Continue** to proceed to the final step.
_Continue_
In the next screen, copy the form **Action URL** (as shown below), then go back to your Softr application and paste it in the **Action URL field** of your form. That’s it. Now, all the emails submitted from your Softr app will be collected in your Mailchimp account under **Contacts**.
_Getting the action URL_
> **Tip**
>
> If you're testing the form submission and not getting anything on Mailchimp, that could be due to **Double Opt-In** being enabled in your Mailchimp settings. When it's enabled, the user that submits the form receives a confirmation email. Only after the submission is confirmed by the user, it is sent to Mailchimp. You can find more details [here](https://mailchimp.com/help/about-double-opt-in/).
## Connecting custom forms to Mailchimp
Let’s create a [Customizable Form](/building-blocks/vikC2AWEpQGkZd4jGyoVxo/advanced-form-features/jCim5VWZePgZuaRsUZBnpG) on Softr with multiple fields and see how we can connect it to Mailchimp to collect all the submissions there.
_Customizable form on Softr_
So, we are going to create a form with three fields (**Email**, **First name**, and **Last name)** and set the destination to Mailchimp.
_Setting form destination_
Now, we need to add the **Action URL**. To get the action URL and receive form submissions on Mailchimp, we need to create a similar form in our Mailchimp account. First, we need to create an **Embedded Form.**
_Embedded forms_
Next, in form settings, we are going to navigate to **Form Fields** and enable two additional fields apart from **Email**. Below, you can see how we’ve enabled three fields, creating a form similar to what we have in our Softr app.
_Creating a form with additional fields_
Lastly, we are going to hit **Continue** and copy the **Action URL** on the next screen, which we’ll need to paste in our form settings on Softr.
_Getting the action URL_
But that’s not all. In order to map all the form fields correctly from Softr to Mailchimp, we also need to specify a **Map to** value for each field. Those values can be found in the same embedded form code under **name**. Below, we’ve located the name of the **First name** field.
_Name of the field_
You should copy the values for all your fields (including the **Email** field) and add them to your Softr form for each field under **Map to**.
_Filling in the “Map to” value_
And we’re done. Let’s do a test submission to make sure it works correctly.
_Doing a test submission_
---
# Mailerlite
Source: https://docs.softr.io/integrations/mailerlite
With MailerLite you can collect emails from your users through any email capture form. All the collected emails will be sent to and stored in your MailerLite account.
## **How to integrate MailerLite with Softr**
MailerLite integration can be applied to any block with email capture (CTA, Hero section, Form etc). For instance, if you are configuring a [CTA with email capture](/6772b65a34c84bfdbe1bc16e8b03f525), you will see an "Add to Mailerlite" option under the submit button's **Action.**
_“Add to Mailerlite” action_
As soon as you choose this option, a new field will appear, where you need to provide the MailerLite **Action URL** to link the email capture form to your MailerLite account.
_“Action URL” field_
So, let's see how you can get the **Action URL** from MailerLite.
## **How to locate MailerLite Action URL**
1. **Create a Subscribers Group**
Log into your MailerLite account, go to **Subscribers => Groups**,and create a group (or use an existing group if you already have one).
_Creating a group_
2. **Create an embedded form**
Then go to **Forms => Embedded Forms** and create an embedded form as shown below.
_Creating an embedded form_
3. **Select a Subscribers Group for the Form**
After entering a name, you'll see the next step, where you need to select the Subscribers group for the form. Choose the group where you want the contacts to be stored and hit **Continue**.
_Selecting a Subscribers Group_
In the next screen, just hit **Done Editing** to finalize the form.
_Finalizing the form_
4. **Getting the Action URL of the Form**
Finally, you'll be taken to your form's **Overview** page, where you should scroll down to the **Embed form into your website** section and switch to the **HTML code** tab. Here, you need to locate the action URL of the form (can also search for "action" using browser search with Ctrl+F), and copy the URL (highlighted below).
_Getting the Action URL_
5. **Adding the URL on Softr**
Lastly, you just need to add the URL in the **MailerLite** field of your Button.
_Adding the Action URL_
That's it. You can now publish your form and start collecting subscriptions. See how that works below.
_Testing the email capture_
> **Tip**
>
> If you're testing the form submission and not getting anything on MailerLite, that could be due to **Double Opt-In** being enabled in your Form settings. When it's enabled, the user that submits the form receives a confirmation email. Only after the submission is confirmed by the user, it is sent to Mailerlite. You can find more details on that [here](https://www.mailerlite.com/help/how-to-use-double-opt-in-when-collecting-subscribers).
## Sending forms to MailerLite
In the previous section, we discussed how to capture emails with MailerLite, however you might also need to map a whole form with multiple field. Let's say you have a [Customizable Form](/building-blocks/vikC2AWEpQGkZd4jGyoVxo/advanced-form-features/jCim5VWZePgZuaRsUZBnpG)
on Softr with the following fields: **Name**, **Email**, and **Message**.
_A Customizable Form on Softr_
In order to receive the form submissions on MailerLite, you should build a similar form there as shown below.
_A custom form on Mailerlite_
Next, in the form configuration page, you need to go to the **HTML code** tab of the **Embed form into your website** section and, apart from grabbing the **Action URL** of the form, you should get the names of corresponding fields (e.g. **fields\[name]** for the **Name** field as shown below).
_Getting field names_
These names need to be pasted inside the **Map to** parameter of each of the form fields.
_Mapping the form fields_
As soon as you do the same for the rest of the fields and add the **Action URL** (discussed in the previous section on email capturing with Mailerlite), you're all set. Now, you can start receiving form submissions on MailerLite. Let's test the form to see how that works.
_Testing the form submission_
---
# Typeform
Source: https://docs.softr.io/integrations/typeform
In this tutorial, we'll go through the process of adding a [Typeform](https://www.typeform.com/) form on a Softr app.
## Getting the form embed code
In your Typeform account, open the form that you want to add to your site, and hit **Share** in the top navbar.
_Share form_
Further on, you need to choose the **embed mode**, and you can also configure the design and some advanced settings (each mode has its specific settings).
_Embed mode_
As soon as the embed is ready, hit the **Get the code** button and copy the embed code, which you'll then need to add to your Softr app. The next section shows how to add the embed code for all the modes except the **Full-page** mode. For adding a **Full-page** code, please proceed to the corresponding section further in this article.
## Adding the Embed Code
The embed code can be added inside a [Custom Code](/custom-code/3idxDhKqz1qPdqBuWbs61G/custom-code-block-overview/6XNrxFopUEiwbWipq81Eq1) block. You just need to paste the code inside the block as shown below.
_Adding embed code inside the Custom Code block_
## Adding a Full-Page Embed Code
If you want to add a Full-page Typeform embed, you can use the [Custom Code](/custom-code/3idxDhKqz1qPdqBuWbs61G/custom-code-block-overview/6XNrxFopUEiwbWipq81Eq1) section inside **Page Settings**. Just paste the code inside the **Header** or **Footer** area.
_Adding the code to a page_
---
# Crisp
Source: https://docs.softr.io/integrations/crisp
## Adding your website
To integrate Crisp on your Softr app, you need to add your site domain and name when registering on Crisp or in **Settings => Website Settings => Add a new website**.
_Add a new website_
Add your website details as shown below.
_Adding website details_
## Getting the website ID
As soon as your site is set up, go ahead and connect Crisp. First, you need to click **Integrations**
next to your site name in **Settings => Website settings**.
_Integrations_
In the pop-up that appears next, choose the **HTML** option.
_Selecting the HTML option_
In the HTML code, locate the **Website ID** and copy it.
_Locating Website ID_
## Adding the Website ID in Softr Studio
Finally, go back to Softr Studio and paste the code in **Settings => Integrations => Crisp**.
_Adding Website ID in Softr_
Save the settings, publish your app again, and you’re done. Now, the Crisp chat icon should appear on your site, allowing your customers to contact you at any time.
_Crisp Chat activated on the site_
---
# Drift Chat
Source: https://docs.softr.io/integrations/drift-chat
##
Here we’ll go through the process of adding the Drift widget to your site. In your Drift account, you need to go to **Settings => Drift widget**, scroll down to **Install**, and locate the **JavaScript** option.
_Drift widget setup_
Hit **Copy** to copy the JavaScript code.
_Copying the JS code_
In your Softr Studio, go to **Settings => Integrations => Drift Chat** and paste the code inside the field.
_Adding Drift widget code in Softr_
That’s it. As soon as you save the updated settings and republish your app, you’ll see the Drift widget appear on the site, as shown below.
_Drift widget published on site_
---
# HubSpot Chat
Source: https://docs.softr.io/integrations/hubspot-chat
## Creating a Chatflow
To add a chat widget to your Softr app, you first need to create a chatflow in your HubSpot account to be able to receive messages. To do that, go to **Conversations => Chatflows => Create chatflow.**
_Creating a Chatflow_
In the next step, choose **Website**.
_Choosing the “Website” option_
Then select **Live chat**.
_Selecting the “Live chat”option_
Next, select the **Inbox** and a **Language** for the chatflow, and hit **Create**. You can find more info on configuring these and other parameters of the chatflow [here](https://knowledge.hubspot.com/chatflows/create-a-live-chat).
_Selecting Inbox and Language_
Lastly, you enter the edit page where you can [customize](https://knowledge.hubspot.com/chatflows/create-a-live-chat) your chatflow, and, as soon as you are done, enable it in the upper right corner of the page.
_Enabling chatflow_
So, your chatflow is ready, and you can go ahead and add the tracking code in your Softr app to start displaying the chat widget to your visitors.
## Getting the Tracking Code
Go to **Settings** in your HubSpot account.
_Accessing settings_
Scroll down to **Tracking Code** and copy the **Embed code**.
> **Tip**
>
> The location of the tracking code can be different depending on your HubSpot subscription plan. Check out this [article](https://knowledge.hubspot.com/reports/install-the-hubspot-tracking-code) for more details.
_Getting the tracking code_
## Adding the tracking code in Softr studio
In Softr Studio, go to **Settings => Integrations => HubSpot Chat**, and enter the **Tracking Code**.
_Adding the tracking code in Softr_
Save the **Settings**, republish your app, and you're done. Now, the chat widget should start appearing on your site.
_HubSpot chat widget added_
---
# Intercom
Source: https://docs.softr.io/integrations/intercom
Intercom is a messaging platform that allows you to communicate with prospective and existing customers. Here, we'll go through the process of adding the Intercom chat widget to your Softr app.
## Locating Intercom Workspace ID
First, you need to locate your Intercom **workspace ID** (app ID). It can be found in the URL of any page you have open in Intercom. It's the code that comes after **apps/**.
_Locating the workspace ID_
The workspace ID can also be found in Settings. In your Intercom account, hover over the account icon in the lower left corner and go to **Settings**.
_Navigating to Settings_
Then go to **Installation => Web** and choose the **With code** option under **Install chat for visitors.**
_Widget installation_
Scroll down and copy the **app\_id**.
_Copying app ID_
## Adding Workspace ID in Softr Studio
So, after copying the workspace ID, navigate to **Settings => Integrations => Intercom** in your Softr Studio and paste the ID.
_Adding Intercom ID in Softr_
That's it. As soon as you save your settings and republish your Softr app, the Intercom chat widget will start appearing.
_Intercom widget added to site_
---
# Google Maps
Source: https://docs.softr.io/integrations/google-maps
You can add a Google Map to your application using the [Contact form with Map](/79a9d5f0f13c4e14a510db94242e668c) or the [Map](/building-blocks/vikC2AWEpQGkZd4jGyoVxo/map/e1zLdwuFNU7A9WakvLBHsq) block. Here are the steps to do that:
## ****Step 1: Get the API key****
To use the Maps in your application you must have an API key. The API key is a unique identifier that is used to authenticate requests associated with your application for usage and billing purposes.
Go to this page and follow the instructions described in [Google documentation](https://developers.google.com/maps/documentation/javascript/get-api-key?hl=en).
## ****Step 2: Copy the API key****
Copy the API Key created for your project (Note: you need to create a new project if you don't have one).
## ****Step 3: Apply the API key****
Go back to your Softr app and add the key in [Settings](/application-settings/n3K2UEfpC9BpHgakMzUU5Y/general-settings/7YdGy1J8X2tjJSv8BGvWQU) ⇒ Integrations ⇒ Google Maps Integration as shown below.
_Adding the map API key_
Now, you can go to your map and start configuring it.
---
# AtomChat
Source: https://docs.softr.io/integrations/atomchat
AtomChat is a great solution for adding a group chat or video conferencing functionality for your users if you're building an online community, a social network, an internal collaboration tool, and so on.
[Here](https://help.atomchat.com/portal/en/kb/articles/add-atomchat-to-your-softr) you can find a detailed step-by-step guide on integrating AtomChat with Softr. You can also [add a chat option directly to user profiles](https://help.atomchat.com/portal/en/kb/articles/chat-with-a-user-from-their-profile-softr).
---
# Stripe Checkout
Source: https://docs.softr.io/integrations/stripe-checkout
With Stripe Checkout’s serverless integration for simple one-time payments or recurring subscriptions, you are able to charge your customers with a click of a button.
## **Connecting Stripe**
Connecting to Stripe requires you to have an account on Stripe. If you don't have an account yet or new to Stripe, please get yourself familiar with the [Stripe documentation](https://stripe.com/docs) first.
After making sure you have a [Stripe account](https://stripe.com/docs), [Products](https://stripe.com/docs/billing/subscriptions/set-up-subscription#without-code) & [Pricing Plans](https://stripe.com/docs/billing/subscriptions/set-up-subscription#without-code) defined, proceed with these steps to connect Stripe to your Softr's application.
1. **Step 1:Enable Checkout on Softr Side**
To enable checkout on Softr side, you need to first add your Stripe's authentication keys to Softr. You need to navigate to the API keys page on your Stripe checkout and copy the **Publishable key** and **Secret key** to your Softr app's **Settings => Integrations => Stripe Checkout** page as shown below.
_Adding Stripe authentication keys on Softr_
2. **Step 2:Add a Checkout to your Application**
To collect payments from your users, you can either use the [Simple Checkout Form](/integrations/etS18kJqm1fuD58KCsjC3z/simple-checkout-form/tKt3f5cV2CxsFLGM1aaNYX) or link to a Stripe checkout from your site (e.g. using the [Pricing block](/integrations/etS18kJqm1fuD58KCsjC3z/layout-pricing-in-card-view-with-details/pNspR4mKu6spj1KSzRf4p7)).
You can also add a [Simple Billing Form](/integrations/etS18kJqm1fuD58KCsjC3z/simple-billing-block/9oj8iqzqLhBWFHVt2UAY1K) or connect a [Stripe Custome Portal](/integrations/etS18kJqm1fuD58KCsjC3z/stripe-customer-portal/3B7NhNtJ4RvipBwi7FwUtF) to allow your users to view and edit their billing details.
---
# Buy me a Coffee
Source: https://docs.softr.io/integrations/buy-me-a-coffee
Buy Me a Coffee is a simple tool for creators to get paid and connect with their fans. To start receiving payments through Buy Me a Coffee, you just need to provide a link to your Buy Me a Coffee page. There are a few ways to do this, which we'll examine below.
## Profile Link
You can copy the link to your profile from your Buy Me a Coffee account's dashboard and put it as an **External URL** under any button in Softr Studio. See below.
_Adding a link to a Buy Me a Coffee profile_
## Buy Me a Coffee Button
You can generate a button in your Buy Me a Coffee account. From your page, navigate to the **Dashboard** and select the **Website Buttons** option. Then, you just need to **Copy code** and place the code inside a [Custom Code](/custom-code/3idxDhKqz1qPdqBuWbs61G/custom-code-block-overview/6XNrxFopUEiwbWipq81Eq1) block in Softr Studio. See how it's done below.
_Adding a Buy Me a Coffee button to Softr_
---
# Gumroad
Source: https://docs.softr.io/integrations/gumroad
Gumroad is an online platform for creators to sell their products directly to consumers. The platform is mostly intended for selling digital content like albums, ebooks, music, tutorials, and so on.
Let's see how you can integrate Gumroad with Softr to start selling. When you create a product on Gumroad, it is assigned a unique link as shown below.
_Getting product URL_
So, when creating a product on Softr, you just need to have a button (e.g. "Buy Now") that will open the corresponding Gumroad product link. In most of the cases, you'll be importing a list of products from Airtable. Let's assume you've created your app based on our e-commerce template (see how to create an app with template Airtable base [here](https://studio.softr.io)).
Thus, you have your products along with their names, images, descriptions and so on. Also, each product has a **View Details** button, which is linked to the item details page. Let's modify the button to open the product's Gumroad page instead.
_“View Details” button on a product_
To achieve that, you need to create a new field in your Airtable base, where each product's Gumroad link will be stored. So, let's add a new column and call it "Gumroad Link.”
_Gumroad link in product list on Airtable_
Now, in your product listing configuration, you need to scroll down to the **View Details**
button, set the **Action** to **Open external url,** and set the Url to the "Gumroad Link" field.
_Configuring the button click action_
That's all. Now, when the users click on the **View Details** button on the product, they'll be taken to the product's Gumroad page.
_Testing the Gumroad setup_
You can also add the Gumroad link on the product details page or anywhere else the same way. You just need to set the button **Action** to **Open external Url** and set the corresponding Airtable field with product links.
Alternatively, you can add the link directly if the product is a standalone item (e.g. you are using a [CTA button](/building-blocks/vikC2AWEpQGkZd4jGyoVxo/cta/oPDoXzSUpMuKki92WuBDDH)), as shown in the example below.
_Add Gumroad link to Softr_
---
# PayPal
Source: https://docs.softr.io/integrations/paypal
You can easily integrate PayPal on your Softr app to start receiving payments. You can either add a single button or, if you're importing a list of products from a [data source](/4230abecf813402aa2926466c313290a), you can add a PayPal link for each product in your database, so that customers can visit your store and make purchases. Let's discuss each case separately.
## Adding a Single Button
Your starting point is
where you can choose the type of button you want to have on your site. After generating the button, the code can be added inside a [Custom Code](/custom-code/3idxDhKqz1qPdqBuWbs61G/custom-code-block-overview/6XNrxFopUEiwbWipq81Eq1) block in your Softr app.
As an example, let’s use the **Buy Now** button:
> **Info**
>
> Make sure you are signed in to PayPal to see the Buy Now option.
Follow PayPal’s configuration steps like providing a Product name and Price:
Once done, click “Save and Create Button”:
You will land on a page with your button code. Copy the code:
Finally, add the link to a [Custom Code](/custom-code/3idxDhKqz1qPdqBuWbs61G/custom-code-block-overview/6XNrxFopUEiwbWipq81Eq1) block:
## Adding links in a data source
Let's assume you've created an e-commerce app. Thus, you have your [product listing](/building-blocks/vikC2AWEpQGkZd4jGyoVxo/list-block/pQhPYuA28VXr5tLLFBcbCU), and each product has a **View Details** button, which should be linked to the item [details page](/building-blocks/vikC2AWEpQGkZd4jGyoVxo/item-details-block-/4bE8XaFbJp45wkAwuWiz8f). On the details page, there's in turn a **Buy Now** button. So, let's customize the **Buy Now** to link it to the item's PayPal **Buy Now** button.
This time, when you create a button, switch to the **Email Link** tab, and copy the code.
### **Adding the Button Link to the Product**
Now, you have the button link and need to add it to your data source to the corresponding product. We are going to use [Airtable](/data-sources/1YYStCJukT15Lh2j93qo9A/airtable/jHX7kfH7QvkVcELQvS3VoX) as our data source and create a **PayPal Link** field to add the button link there.
_The “PayPal Link” field on Airtable_
Next, on our product details page, we are going to set the **Buy Now** button action to **External url** and select the **PayPal Link** field.
_Setting the external URL to the PayPal link field_
So, that's the process for one particular product, and you need to repeat it for all the products, creating a unique PayPal button for each one. When you're done, the Buy Now button on the product page will redirect to the PayPal payment page, as shown below.
_Testing the button_
---
# Layout: Pricing in card view with details
Source: https://docs.softr.io/integrations/layout-pricing-in-card-view-with-details
Using this block, you can display the different pricing options of your product or service. You can also link each option to a corresponding checkout page (internal or external), which we'll discuss a bit later.
_Pricing in card view with details_
Let's review the block settings, which are located under the **Features** tab.
## **Title and Subtitle**
Here, you can customize the **Title** and **Subtitle** of the block.
## **Multiple billing cycles**
You can enable this option if, for instance, you want to show different prices for **yearly** and **monthly** billing. Under **Cycle description**, you can add a custom text for your Yearly option.
## **Pricing Tiers**
Here, you add the details for each of your pricing tiers (Title, Yearly and Monthly prices, Features, etc.).
## **Button**
Each tier has a button that can be used to take the users to the checkout page. If you're using a payment service other than Stripe, you can use the **Redirect to url** option under **Add action** to take the users to your external checkout page.
To use the Stripe Checkout option, your first need to [connect your Stripe account](/integrations/etS18kJqm1fuD58KCsjC3z/stripe-checkout/iBomMEucRZtM2y6HuutYVC) to your Softr app.
_Button action options_
**So, let's select the Stripe Checkout option and start configuring the checkout settings.**
## **Recurring payments**
Enable this if you want to charge your customers periodically based on a specific schedule (e.g. for a monthly subscription). When configuring a product on Stripe, you have the option to set it as **One time** or **Recurring**.
_Choosing a product type on Stripe_
## **Allow promotion codes**
Here, you need to choose if you're going to accept [promotion codes](https://stripe.com/docs/billing/subscriptions/coupons/codes) on your Stripe checkout.
## **Enable automatic tax**
You can select to apply automatic taxes on checkout, which needs to be configured on Stripe.
### **Adding the Tax feature on Stripe**
First of all, if you don't have the Tax feature enabled on Stripe, you can add it from the Features and Products list as shown below.
_Adding the Tax feature_
Now, the Tax settings will become available from your Stripe settings.
_Selecting Tax settings_
### **Configuring tax settings**
Further on, you need to configure your tax settings, setting up **Default product tax category**, **Tax registration locations**, and others.
_Configuring tax settings_
### **Testing taxes**
That's it. Now when you create a new product (or edit an existing one) on Stripe, taxes will be applied automatically for your selected locations based on the **Product tax category**.
_Creating a product_
Let's also see what this looks like from the perspective of your Softr app users.
_User checkout_
## **Plan IDs and Success/Cancel URL**
Now you just need to configure each plan corresponding to your Stripe products. If you have multiple billing cycles, you need to configure "**Monthly Plan"** & "**Yearly Plan"** fields in Softr. In case of a single billing cycle, you will configure only one **"Plan"** field.
_Plan IDs and Success/Cancel URLs_
You can find the **Monthly/Yearly Plan ID** by navigating to your [Stripe Dashboard](https://dashboard.stripe.com/). On the dashboard, open **Products Menu**, select a specific product, and choose the corresponding Plan ID from the Pricing plans list. In case your Products list or Pricing list is empty, please make sure to follow the [Stripe documentation](https://stripe.com/docs/billing/subscriptions/set-up-subscription#without-code) to create Products & Plans first.
And finally, you need to fill out **"Success Url"** and **"Error Url"** fields, which show correspondingly where will customers be redirected upon completion (or cancellation/error scenario) of the checkout process.
> **Tip**
>
> The **"Success Url"** and **"Error Url"** fields are mandatory and Stripe checkout won't work if they are empty or don't start with either http\:// or https\://.
---
# Stripe Customer Portal
Source: https://docs.softr.io/integrations/stripe-customer-portal
Using this block, you can enable your Softr app users to access their personal portal on Stripe to manage their purchases/subscriptions and payment info. To start with, you need to integrate your Stripe account with your Softr app (find out more details on that [here](/integrations/etS18kJqm1fuD58KCsjC3z/stripe-checkout/iBomMEucRZtM2y6HuutYVC)). Next, you should configure your **Stripe Customer Portal** in your Stripe account. Let's see how that's done.
## Configuring Stripe Customer Portal
To access customer portal settings, you need to navigate to **Settings => Billing => Customer Portal** on your Stripe dashboard. Here you can specify what actions your customer should have access to (e.g. Cancel a subscription, Edit payment method, etc.). We won't go into details here, as you can learn more through Stripe [help docs](https://stripe.com/docs/billing/subscriptions/integrating-customer-portal). Just make sure to hit **Save** after making the changes.
Now, let's see how you can provide your customers with access to the portal.
## Setting up the portal block on Softr
_Stripe Customer Portal Block_
To provide your customer with access to the Customer Portal on Stripe you just need to add the corresponding block somewhere on your Softr app. In block settings, apart from titles and the background image, you need to set up the **Redirect URL**.
> **Tip**
>
> The Redirect URL is the page your users will be taken to after hitting **Return** on their **Customer Portal** page.
You'll see this in action a bit later when we show the whole process from the customer's perspective.
## How Customers Access the Portal
Finally, let's see what the portal looks like from the customer's viewpoint. We are going to log into our Softr app with a user account, purchase a subscription, and try to edit subscription details and access payment info using the Stripe Customer Portal. Let's proceed.
We've set up the checkout using the **Simple Checkout Form** (take a look at the [block docs](/integrations/etS18kJqm1fuD58KCsjC3z/simple-billing-block/9oj8iqzqLhBWFHVt2UAY1K) to see how it should be configured).
> **Tip**
>
> We've used the **Simple Checkout Form** in our example, but you can use any of the payment blocks integrated with Stripe (e.g. [Pricing block](/integrations/etS18kJqm1fuD58KCsjC3z/layout-pricing-in-card-view-with-details/pNspR4mKu6spj1KSzRf4p7)).
So, below you can see how the user purchases a Stripe subscription through the checkout form and then uses the portal block we just set up to access his portal on Stripe and make changes.
_Editing details on Stripe Customer Portal_
Notice that, at the end, when the user clicks on **Return to Softr**, he's taken to the portal page, as we had set it that way (under **Redirect URL**) in portal block settings previously. Nevertheless, the **Redirect URL** can be set to any page in or even outside of your Softr app (just needs to start with **https\://**).
---
# Simple Billing Block
Source: https://docs.softr.io/integrations/simple-billing-block
Using this block, you can enable your users to manage their subscriptions and purchases on your Softr app. So, let's see what the steps are involved in the setup.
## Integrating Stripe
The block is supposed to work with Stripe and get all the purchase and subscription info from there, so, first of all, you need to [integrate a Stripe checkout](/integrations/etS18kJqm1fuD58KCsjC3z/stripe-checkout/iBomMEucRZtM2y6HuutYVC) with your Softr app.
> **Tip**
>
> In our example we are going to use the **Pricing** block along with **Stripe Checkout** integration, which will link your users to a separate Stripe checkout page.
> However, you can also use the [Simple Checkout Form](/integrations/etS18kJqm1fuD58KCsjC3z/simple-checkout-form/tKt3f5cV2CxsFLGM1aaNYX) instead (with or without the Pricing block). All the subscription and purchase info of your users processed through the **Simple Checkout Form** will be available via the **Simple Billing Form**.
## Setting up a pricing block
As soon as you're done with Stripe integration, you can proceed with setting up a [Pricing](/integrations/etS18kJqm1fuD58KCsjC3z/layout-pricing-in-card-view-with-details/pNspR4mKu6spj1KSzRf4p7) block, where you offer your Stripe products/subscriptions to your users.
Below, you can see a product that we've set up on Stripe (available in the **Products** section of your Stripe dashboard).
_A product page on Stripe_
Now, we are going to add this product on our Pricing block in Softr. Below, you can see how it's configured.
_Product added in Pricing block_
As you can see, we've set the **Button** action to **Stripe checkout** and enabled **Recurring payments**, as the product we've added is a subscription. Moreover, we've copied the **Monthly** and **Yearly** price IDs from the product page on Stripe as well as added **Success** and **Cancel** URLs, which are mandatory. You can find more info on configuring the Pricing block [here](/integrations/etS18kJqm1fuD58KCsjC3z/stripe-checkout/iBomMEucRZtM2y6HuutYVC).
Other subscription plans or products on your Pricing block can be configured the same way. You might also need to provide your users with coupon codes. So, let's review that part as well.
### **Adding Coupon Codes**
Coupons can be created under **Products => Coupons**. Further on, you need to add a **Promotional Code** for your coupon, and the **Name** of your **Promotional Code** is what you should give to your users to use on checkout. Below you can see how that's set up.
_Setting up a Coupon and Promotional Code_
We'll use this code ("test1234") later on in this guide when demonstrating the checkout and billing management process from your users' standpoint.
So, now, let's proceed to setting up the **Simple Billing Form**.
## Configuring the Simple Billing Form block
We are just going to add the **Simple Billing Form** block on a separate page and configure it. Let's quickly go through the block settings.
_Simple Billing Form overview_
Above you can see an overview of the block configuration. Now, let's go through each setting in detail.
First, we can customize the block **Title** and set a **Background image**. Next we need to set the page that the user is going to be taken to if he/she wants to change the subscription plan (**Change plan**). In our case, it's the page with the **Pricing** block, which we configured above.
### **Invoices**
Next up we have the **Invoices** toggle, which allows the users to view all their invoices (fetched from Stripe).
### **Cancel Subscription**
We can also allow the users to cancel their subscriptions at any time. If we enable this option, a number of other fields appear below, where we can customize the section's title and descriptions as well as what appears on the confirmation pop-up.
Now that we've reviewed the configs from the site owner's perspective, let's see how everything looks from the site users' standpoint.
## Billing Management from the User's Perspective
Below you can see how the user purchases a subscription through the **Pricing** block and is later on able to view his/her subscription along with additional info (e.g. Invoices) using the Simple Billing block as well as cancel the subscription. The user also applies a promotional code during checkout.
> **Tip**
>
> In our example, we've used a subscription-type product from Stripe, but one-off purchase products can be set up in a similar manner.
_Checkout and billing management_
As you can see, after completing the checkout, the user is automatically taken to the page with the **Simple Billing Form**, where he/she can manage his/her details.
---
# Simple Checkout Form
Source: https://docs.softr.io/integrations/simple-checkout-form
_Simple Checkout Form_
Using this block, you can set up paid membership and charge your users for accessing certain sections (pages or blocks) of your Softr app. Prior to setting up this block, you need to [connect Stripe](/integrations/etS18kJqm1fuD58KCsjC3z/stripe-checkout/iBomMEucRZtM2y6HuutYVC) to be able to offer Stripe products (one-time products or subscriptions) to your users. So, let's go ahead and examine the block settings.
## Title and images
_Logo, Title, and Background Image_
To start with, you can add a custom title, logo, and a background image in the **Feature** tab of block settings.
## Product Setup
Next, you need to set up the product that you want to offer to your users.
_Product parameters_
The **Product** dropdown is a list with all your Stripe products. First you need to select a certain product, then fill out the rest of the product fields (**Name, Trial, Price, Interval, Description**) as you wish them to be shown on your checkout page. In the example shown below, we've chosen the **Maker (Website Builder)** product, and set the other fields to their corresponding values.
_Product selection_
Below, you can see how it looks on the actual checkout form.
_Published checkout form_
### Payment details
Here, you can customize the placeholder text for the name and email fields.
### Discount code
_Discount Code section_
Here you can choose to show a discount code field. If it's enabled, you can modify the text for the discount button and coupon input field. **The form will accept** **[coupons](https://stripe.com/docs/billing/subscriptions/coupons)** **defined for the selected Stripe product.**
_Applying a discount code_
### Button
_Button settings_
Here, you can modify the **Text** of the payment submissions button. The **Action** of the button is predefined.
### On checkout
_On checkout_
Lastly, you can choose to which page the user is taken after making the payment.
That's it. As soon as you have provided a checkout for a specific product, you can go ahead and define access conditions (for a [block](/user-groups-and-permissions/3oA6AaFzUiePs2sW2TpYrF/block-visibility/3spA2dfQNrcGcPNmnDXHB3) or a [page](/user-groups-and-permissions/3oA6AaFzUiePs2sW2TpYrF/page-visibility/nWJaN689VKA1TUeaEfzK9u)) for users who have paid for the product.
---
# Facebook Pixel
Source: https://docs.softr.io/integrations/facebook-pixel
The [Facebook Pixel](https://www.facebook.com/business/tools/meta-pixel) is a code snippet placed on your website or web app that lets you track and optimize the audience that visits your site as a result of your Facebook ad campaigns (paid) or organically (unpaid). For instance, if someone lands on your website and then makes a purchase or performs some other action, you can track that activity through Facebook Pixel and tie it to a Facebook Ad. Thus, Pixel tracks all the actions that users make on your website but then ties that traffic directly to an ad if you are running Facebook ads. Then, you can, for instance, retarget your Facebook ads to show them only to your website visitors.
In order to activate the Pixel on your Softr app, you need to locate your **Pixel ID** and add it in **Settings⇒Integrations⇒Facebook Pixel**. Let’s see where you can find the ID.
## Connecting Facebook Pixel
Navigate to Facebook [Ads Manager](https://www.facebook.com/business/tools/ads-manager) and, in the left-hand navigation menu, locate the **Events Manager** tool.
_Navigating to Events Manager_
Next, if you don’t yet have any data connected, a pop-up will appears, prompting you to connect your data. Hit **Connect Data** to continue.
_Connect Data_
Choose the **Web** option and hit **Connect**.
_Connect a website_
Further on, you need to name your Pixel.
_Naming the Pixel_
And also enter your website URL.
_Entering website URL_
In the following screen, you need to choose the connection type. **Conversions API** **+ Meta Pixel** is a more advanced option, and you can learn more about it [here](https://www.facebook.com/business/help/2041148702652965?id=818859032317965). Here, we are going to choose the **Meta Pixel only** option and finalize the setup.
_Connection type_
As soon as you finish setting up your Pixel, you’ll be taken to the **Events Manager Overview**, where you should see all the Pixel-related activity. Here, you need to locate your Pixel ID (shown in the screenshot below) and paste in your Softr app’s **Settings ⇒ Integrations ⇒ Facebook Pixel**.
_Events Manager Overview_
That’s it. Now, you should start receiving activity from your site.
> **Tip**
>
> It can take up to 24 hours before Facebook starts recording activity from the Pixel.
Now, let’s see how you can make sure Pixel is installed correctly on your site.
## Testing Facebook Pixel
If you use Chrome, there’s a handy extensions called [Meta Pixel Helper](https://chrome.google.com/webstore/detail/meta-pixel-helper/fdgfkebogiimcoedlicjlajpkdmockpc) that lets you test Pixel setup on any of your site’s pages. Just activate the extension and open it on any of the pages where you have Pixel installed. Below, you can see how we test it on an app we just installed Pixel on. As you can see, the extension is able to detect the Pixel successfully.
_Testing Pixel setup_
## Tracking more events
What we just did is just the basic setup of Facebook Pixel. However, you can do much more with it, adding [standard and custom events](https://www.facebook.com/business/help/964258670337005?id=1205376682832142) to track such actions as add to cart, purchase, and more.
> **Tip**
>
> You can use the [Header Custom Code](/0392ff65acfe4b1c96923c1aac7982f7) of your Softr page to add the event code.
---
# Google Analytics
Source: https://docs.softr.io/integrations/google-analytics
In this guide, we'll go through the process of integrating **Google Analytics** with your Softr app. You can integrate both **Universal Analytics** and **Google Analytics 4**, and below you can find separate guides for each of the versions.
## Universal Analytics
After [setting up a Google Analytics property](https://support.google.com/analytics/answer/10269537?ref_topic=1009620) for your site, you need to navigate to **Admin**, choose the required property, and click **Tracking Info**, as shown below.
_Locating tracking info_
From the opened dropdown, click on **Tracking Code** and copy the **Tracking ID** (starting with "UA-") as shown below.
That's it, now you just need to paste the ID in **Settings =>** **Integrations => Google Analytics**
in the left-hand toolbar of your [Softr Studio](https://studio.softr.io) and hit **Save.**
_Adding tracking code in Softr_
## Google Analytics 4
After setting up a [Google Analytics 4 property](https://support.google.com/analytics/answer/9304153#zippy=%2Cweb%2Cadd-the-tag-to-a-website-builder-or-cms-hosted-website-eg-wordpress-shopify-etc), you need to go to **Admin**, select the required **property** and navigate to **Data Streams**.
_Accessing data streams_
Next, select the data stream.
_Selecting the data stream_
In the screen that comes next, locate the **Measurement ID** and copy it.
_Getting the Measurement ID_
Finally, you just need to go back to your Softr app and add the ID into [Settings](/application-settings/n3K2UEfpC9BpHgakMzUU5Y/general-settings/7YdGy1J8X2tjJSv8BGvWQU)**⇒Integrations ⇒ Google Analytics** as shown in the following screenshot.
_Applying the Measurement ID_
---
# Google Tag Manager
Source: https://docs.softr.io/integrations/google-tag-manager
The process of integrating Google Tag Manager is pretty straightforward. After creating a container, you just need to locate your **Container ID**. [Here](https://support.google.com/tagmanager/answer/6103696) you can find all the details.
After locating the **Container ID**, you need to copy it and navigate back to your Softr app. Then, you should paste it **Settings => Integration => Google Tag Manager,** and you’re done!
_Adding GTM container ID_
# Alternate Method
> **Tip**
>
> **NOTE:** Do not combine this method with the standard method above. Doing so will cause your tags to trigger twice and you will receive double the data you should.
You can also configure Tag Manager by clicking on the **Settings** icon on the left side of Softr Studio and clicking on **Custom Code.**
_Clicking on settings, then custom code_
Then in a new tab go to [tagmanager.google.com](https://tagmanager.google.com), click on the Account you’ve set up.
_Choose your account from the list_
Then, click on the container ID in the upper right corner.
You will see header and footer codes which can be copied and pasted into the Header and Footer sections of the Custom Code panel of Softr. Don’t forget to click **Save** when finished.
_Custom header and footer code to be copied._
_Be sure to paste the codes in the correct places, then click Save._
---
# Microsoft Clarity
Source: https://docs.softr.io/integrations/microsoft-clarity
[Microsoft Clarity](https://clarity.microsoft.com/projects?utm_medium=partner\&utm_source=Softr\&utm_campaign=Growth) is free analytics tool to help you better understand how your users interact with your website. Using the platform, you can generate heatmaps to see where users click on your pages, what they ignore, and so on. Further on, it offers session recording that you can use to get even deeper insights into user experience and test out new ideas. Clarity also integrates with such tools as [Google Analytics](https://docs.microsoft.com/en-us/clarity/ga-integration) to help you better analyze and structure the user data.
Using our Clairty integration, you can easily apply the tool to your Softr application and start collecting insights. Let's quickly go over the steps.
## Getting the project ID
To get started, you need to [create a project](https://docs.microsoft.com/en-us/clarity/getting-started#add-a-new-project) in your Clarity dashboard and connect it to your Softr app under **Website URL**. As soon as the project is ready, go to project settings and copy the ID. Below, you can see where the ID is located and how we've added our Softr application to the Clarity project.
_Getting the Clarity project ID_
## Adding the project ID on Softr
Now that you have the Project ID, navigate to your Softr app's **Settings => Integrations => Microsoft Clarity** and add it there.
_Adding Clarity ID on Softr_
As soon as you **Save your settings** and **publish your Softr app**, you're ready to go!
## Testing the integration
If you don't yet have actual users on your Softr app, you can just perform some activity yourself, and within a few hours it will start appearing in your Clarity dashboard. As soon as you start gathering data, you can start monitoring activity heatmaps, watching user session recordings, and so on.
_User session recording on Clarity_
---
# Weglot
Source: https://docs.softr.io/integrations/weglot
With **Weglot**, you can create a multilingual website on Softr. [Here](https://support.weglot.com/article/320-softr-integration-setup), you can find a step-by-step guide that goes through the whole process.
> **Tip**
>
> In order to translate dynamic content ([List](/building-blocks/vikC2AWEpQGkZd4jGyoVxo/list-block/pQhPYuA28VXr5tLLFBcbCU), [Table](/building-blocks/vikC2AWEpQGkZd4jGyoVxo/table-block-/j7rGwu7J7zuU69h3bZ7HFe), and other blocks linked to external [data sources](/4230abecf813402aa2926466c313290a?pvs=25)), please refer to the [dynamic content translation guide](https://support.weglot.com/article/253-how-to-translate-dynamic-content) by Weglot.
---
# API Setup and Endpoints
Source: https://docs.softr.io/softr-api/api-setup-and-endpoints
You can generate an API token for your Softr account to be used when interacting with the API endpoints. Let's first see how you can generate the token, and then we'll review the available endpoints and provide API call examples.
> **Tip**
>
> You need to be **the owner of the application or a workspace collaborator** to be able to make API calls. Thus, [guest collaborators](/workspace-and-billing/jZP6yaeXMiJCuB6HhS4xKd/workspaces-and-applications/kTbEWSYXhBCbtTB4K9dpKs) of the application won’t be able to make calls.
> **Note**
>
> Depending on your needs, you can also consider using a [Call API](/actions/ntEfT9zSJk6aY54G6W5KGU/call-api/i9f1s3w9wib3oRmS4HZ7MX) action.
## Generating an API token
You authenticate API calls with a **Personal Access Token**. To create one:
1. Open your Softr [Dashboard](https://studio.softr.io/dashboard), click on your workspace in the top-left corner, and go to **API tokens**.
2. Click **Create**, give your token a recognizable name, and pick an expiration period.
_Name your token_
3. Define the **scopes** — choose what the token can access and the permissions it should have — then click **Continue**.
_Define scopes_
4. Copy the token and store it somewhere safe — for security reasons it's shown only once.
_Copy your token_
You'll pass this token in the **Softr-Api-Key** header of every request (see the examples below).
That's it. Now you have your API token that you can use when interacting with your Softr apps through the API. Let's proceed to see what endpoints are available.
> **Tip**
>
> Make sure to have your **Softr app published** before making API calls.
## API Endpoints
### **Create User**
This endpoint allows creating a user inside the specified Softr app within your account. Below is an example of an API call.
```javascript
curl --request POST 'https://studio-api.softr.io/v1/api/users' \
--header 'Softr-Api-Key: uYGskr7MqMeRYrjQjsB8uEQ8n' \
--header 'Softr-Domain: yourdomain.com' \
--header 'Content-Type: application/json' \
--data-raw '{
"full_name": "John Richardson",
"email": "johnr@gmail.com",
"password": "12345678",
"generate_magic_link":true
}'
```
Here, you need to replace the value next to **Softr-Api-Key** with the API token you've generated and add your Softr app's domain/subdomain instead of **yourdomain.com**.
Next, you need to provide the **Full Name** of the new user along with an **Email** and **Password** (replace the values next to **full\_name**, **email**, and **password**).
> **Tip**
>
> If you don't specify a password, it will be generated for the user automatically.
Finally, you can set the value of **generate\_magic\_link** to "true" or "false" depending on whether you want to generate a [Magic Link](/add-and-manage-users/pxnkp9H3qyEVMF6XUceqnj/add-or-import-users-manually/g5R1bGnBTFJ3sWLR8Mgdng) for the user or not.
### **Delete User**
Using this endpoint, you can delete a user from the specified Softr app. Bellow is an example of an API call.
```javascript
curl --location --request DELETE 'https://studio-api.softr.io/v1/api/users/user@softr.io' \
-header 'Softr-Api-Key: pYSskw7MqMeRUgjQtsf9uRQ5n' \
-header 'Softr-Domain: yourdomain.com'
```
Just replace **
** with the actual email of the user you need to delete as well as provide your API token (the value next to **Softr-Api-Key**) and the domain/subdomain of the Softr app (the value next to **Softr-Domain**) you want to delete the user from. **The rest needs to remain the same as in the example.**
### **Deactivate User**
Using this endpoint, you can deactivate a user in the specified Softr app. Deactivated users cannot log in and don't count toward your plan's user limit, but their record is retained and they can be re-activated later. Below is an example of an API call.
```javascript
curl --location --request POST 'https://studio-api.softr.io/v1/api/users/user@softr.io/deactivate' \
--header 'Softr-Api-Key: pYSskw7MqMeRUgjQtsf9uRQ5n' \
--header 'Softr-Domain: yourdomain.com'
```
Just replace **** with the actual email of the user you need to deactivate as well as provide your API token (the value next to **Softr-Api-Key**) and the domain/subdomain of the Softr app (the value next to **Softr-Domain**) you want to deactivate the user in. **The rest needs to remain the same as in the example.**
### **Activate User**
Using this endpoint, you can re-activate a previously deactivated user in the specified Softr app. Below is an example of an API call.
```javascript
curl --location --request POST 'https://studio-api.softr.io/v1/api/users/user@softr.io/activate' \
--header 'Softr-Api-Key: pYSskw7MqMeRUgjQtsf9uRQ5n' \
--header 'Softr-Domain: yourdomain.com'
```
Just replace **** with the actual email of the user you need to activate as well as provide your API token (the value next to **Softr-Api-Key**) and the domain/subdomain of the Softr app (the value next to **Softr-Domain**) you want to activate the user in. **The rest needs to remain the same as in the example.**
### **Invite User**
Using this endpoint, you can send an invitation email to an existing user of the specified Softr app. Once invited, the user's status changes to **Invited**. Note that the **app must be published** for invitations to be sent. Below is an example of an API call.
```javascript
curl --location --request POST 'https://studio-api.softr.io/v1/api/users/user@softr.io/invite' \
--header 'Softr-Api-Key: pYSskw7MqMeRUgjQtsf9uRQ5n' \
--header 'Softr-Domain: yourdomain.com'
```
Just replace **** with the actual email of the user you need to invite as well as provide your API token (the value next to **Softr-Api-Key**) and the domain/subdomain of the Softr app (the value next to **Softr-Domain**) you want to invite the user in. **The rest needs to remain the same as in the example.**
### **Generate a Magic Link for the User**
Using this endpoint, you cangenerate a [Magic Link](/add-and-manage-users/pxnkp9H3qyEVMF6XUceqnj/add-or-import-users-manually/g5R1bGnBTFJ3sWLR8Mgdng) for the specified user in your Softr app. Bellow is an example of an API call.
```javascript
curl --location --request POST 'https://studio-api.softr.io/v1/api/users/magic-link/generate/user@softr.io' \
--header 'Softr-Api-Key: pYSskw7MqMeRUgjQtsf9uRQ5n' \
--header 'Softr-Domain: yourdomain.com'
```
Just replace **** with the actual email of the user as well as provide your API token (the value next to **Softr-Api-Key**) and the domain/subdomain of your Softr app (the value next to **Softr-Domain**).
### Sync a Single User, Group of Users, or All Users
Use this endpoint to sync a single user, an array of users, or if no email is included, trigger a user sync for all users.
**Single User or Group of Users:**
```javascript
curl --location --request POST 'https://studio-api.softr.io/v1/api/users/sync' \
--header 'Softr-Api-Key: pYSskw7MqMeRUgjQtsf9uRQ5n' \
--header 'Softr-Domain: yourdomain.com'
--data-raw '["email1@example.com", "email2@example.com", "email3@example.com"]'
```
**Sync All Users:**
```javascript
curl --location --request POST 'https://studio-api.softr.io/v1/api/users/sync' \
--header 'Softr-Api-Key: pYSskw7MqMeRUgjQtsf9uRQ5n' \
--header 'Softr-Domain: yourdomain.com'
```
### **Validate an Authentication Token**
Using this endpoint you can validate a user authentication JWT token. This could be used in cases when you use Softr users data (e.g. to show content based on user ID) in external systems outside of Softr and need to authenticate the users with Softr. Here's how you can do that. The following is an example of an API call, where you need to replace **"yourdomain.softr.app"** with your Softr subdomain or custom domain you have connected as well as use the specific token you need to authenticate instead of **your jwt token value**.
```javascript
curl --location --request POST '[https://yourdomain.softr.app/v1/api/users/validate-token](https://yourdomain.softr.app/v1/api/users/validate-token)' \
--header 'Content-Type: application/json' \
--data-raw '{"jwt":"your jwt token value"}'
```
## Use Cases
There are certainly a lot of different use cases for interacting with the Softr API. But if you're working with no-code tools, you can make API calls with such tools as Zapier or Integromat. In subsections to this article, we consider some use cases involving [Zapier](/softr-api/tTFQ5vSAUozj5MsKixMH8C/use-case-adding-users-through-zapier/mhCMmdRcJL2UDsprwzFYuT) and [Make](/softr-api/tTFQ5vSAUozj5MsKixMH8C/use-case-adding-users-through-make-formerly-integromat/vFH1YQTF7At7FwCYSmJKYz) to take you through the setup process.
---
# Use Case: Adding Users through Zapier
Source: https://docs.softr.io/softr-api/use-case-adding-users-through-zapier
**Option 1: Using Zapier's Softr app**
Let's see how you can use the API to add users via Zapier. In this example, we are going to sync a Softr App with Google Sheets using Zapier's Softr app (this is solely for demonstration purposes, and we don't recommend storing user data on Google Sheets or similar sources). Let's proceed.
1. **Configuring the Action**
In the Action search bar enter "softr" and select the Softr action.
_Locating the Softr app_
Next, we are going to select the **Action Event**. In our case, we need to choose "**Create a user**."
_Choosing the Create User action event_
Further on, we need to link our Softr account (by entering the API key, we generated previously), then add the Application domain, map the **Email**, **Name**, and **Password** fields. We can also set to generate a [Magic Link](/add-and-manage-users/pxnkp9H3qyEVMF6XUceqnj/add-or-import-users-manually/g5R1bGnBTFJ3sWLR8Mgdng), but we are going to set it to **False** in our case. See below.
_Connecting account and domain and mapping fields_
That's it. Now, as soon as you activate your Zap, all the new users added to your spreadsheet, will be added to your selected Softr app as well.
**Option 2: Using custom webhook**
In this use case, we are going to add users to a Softr app using Zapier's **Custom Webhook**
instead of the Zapier Softr app. So, the first step (**Setting the Trigger**) is going to be similar to that of **Option 1**.
_Users data_
1. **Setting the Trigger**
First of all, we're going to create a spreadsheets with **Name**, **Email**, and **Password** columns to store user data.
_Users sheets_
Further on, we'll create a Zap on Zapier and set the **trigger** for each new row creation in our Google sheet. See below.
_Setting the trigger_
Next, we'll test the trigger and proceed to configuring the **Action** to define what's going to happen when the initial event is triggered.
2. **Configuring the Action**
In the Action search bar enter "webhook" and select **Webhooks by Zapier** (please note that this is a **paid** feature).
_Selecting “Webhooks by Zapier”_
In the following screen, we need to select **POST** as the **Action event** since we need to create a user using the POST request as described above.
In the next screen, we need to fill in all the necessary details based on the [create user endpoint](/softr-api/tTFQ5vSAUozj5MsKixMH8C/api-setup-and-endpoints/j1PrTZxt7pv3iZCnZ5Fp19). Thus, we need to set the **URL** to "", set the **Payload Type** to "json", and map the **data** as shown below.
_URL, Payload Type, and Data Mapping_
The following configs can be left intact, and we just need to add the **headers** using our **API key**
and **domain** as shown below.
_Headers configured_
3. **Testing the Action**
That's it. Now, we just need to hit Continue and test the action. As you can see below, as soon as we do the test, the user we had added earlier on Google Sheets is added to our Softr app. So, as soon as you make sure it's working correctly, you can turn on the Zap to start the automation.
_Testing the action_
## **Deleting a User**
The [delete request](/softr-api/tTFQ5vSAUozj5MsKixMH8C/api-setup-and-endpoints/j1PrTZxt7pv3iZCnZ5Fp19) can be implemented in a similar way through a custom webhook.
## Zapier templates for Softr
Zapier offers a number of ready-made templates for Softr (the list is available [here](https://zapier.com/apps/softr/integrations)) that let you select from a variety of use cases and get started easily. So, let’s see what kind of templates are available
_Zapier templates for Softr_
### Database/spreadsheet templates
Most of the templates involve spreadsheet or database tools such as Google Sheets, Airtable, or Coda. Those work the following way: every time a new record/row is added to the database, a new user is automatically created on Softr based on that record/row.
### Form templates
This category involves form builder platforms such as Google Form, Jotform, and TypeForm. The templates create a new Softr user for each new form submission. Let’s say you’ve built an online community with Softr, and there are several community moderators. Using one of these templates, you can provide a way for your moderators to add new users directly from the app user interface instead of giving them access to your Softr app’s [studio](https://studio.softr.io).
### Stripe template
This template connects [Stripe](/integrations/etS18kJqm1fuD58KCsjC3z/stripe-checkout/iBomMEucRZtM2y6HuutYVC) to your Softr app, creating a new Softr user for each new Stripe customer you get. Let’s say you have an online shop that processes payments using Stripe, and you’ve also created a Softr application for your shop customers to interact with one another and also get access to perks. Using this template, you can automatically sync all your customers along with their details with your Softr-built app.
### Webhook template
This template just connects Softr with a [Zapier webhook](https://zapier.com/features/webhooks), which lets you receive data from any service even if it’s not available in Zapier.
---
# Use Case: Adding Users through Make (formerly Integromat
Source: https://docs.softr.io/softr-api/use-case-adding-users-through-make-formerly-integromat
In this use case, we are going to use the API to add users to a Softr app via Make. We are going to add users on Airtable and send them to Softr. Let's proceed.
**Option 1: Make's Softr module**
1. **Setting a Trigger**
First of all, we're going to create a table on Airtable with **Name**, **Email**, **Password**, **Magic Link, Created Date/Time** (needed for watching record creation in Make) columns to store user data.
_Table setup on Airtable_
Then, we'll go to Make dashboard, create a new scenario, and add a trigger that watches for new records on our selected table. See below.
_Creating the trigger_
Now, we need to set up an **Action** to add the users received from Airtable. There are two options for this:
- **Make's Softr module;**
- **Custom HTTPrequest.**
Let's consider each option separately.
2. **Configuring the Action**
Let's add a new module to the scenario, search for "Softr," and select it.
_Locating the Softr module_
Then, we are going to choose the **Create a User** option.
_Choosing the Action_
Next, we need to establish a connection with our Softr account and app, inputing the [Softr API key](/softr-api/tTFQ5vSAUozj5MsKixMH8C/api-setup-and-endpoints/j1PrTZxt7pv3iZCnZ5Fp19) and the domain of the app we want to add users to.
_Adding a Softr connection_
Lastly, we need to map the user fields from our table as shown below.
_Mapping the user fields_
> **Tip**
>
> As you can see, we haven't mapped the **Magiclink** field from the table but have just set the value to **Yes** to generate one automatically. We can sync it back to a [Airtable](/f001252ed01e495d8c0f8e2588f06107) if we [connect it to Softr](/add-and-manage-users/pxnkp9H3qyEVMF6XUceqnj/syncing-users-with-a-data-source/hshRGygHr4T33EnaLntGf9), which we'll discuss in **Step 3**.
That's it. Now, we just need to save the module and the scenario is ready. Let's test it to make sure everything is working correctly.
3. **Testing the Scenario**
Let's add a new user to our table and check if it's sent to our Softr app successfully.
> **Tip**
>
> This is optional, but we are also going to [connect our Softr users base](/add-and-manage-users/pxnkp9H3qyEVMF6XUceqnj/syncing-users-with-a-data-source/hshRGygHr4T33EnaLntGf9) to the same Airtable base and table at the beginning to sync user data **from** **Softr to Airtable** as well. This way, the magic link that's been generated when fetching the user **from Airtable to Softr** will be stored in Softr and eventually **synced back to Airtable**.
_Testing the scenario_
**Option 2: Using a Custom HTTP Request**
1. **Setting a Trigger**
First of all, we're going to create a table on Airtable with **Name**, **Email**, **Password**, **Magic Link, Created Date/Time** (needed for watching record creation in Make) columns to store user data.
_Table setup on Airtable_
Then, we'll go to Make dashboard, create a new scenario, and add a trigger that watches for new records on our selected table. See below.
_Creating the trigger_
Now, we need to set up an **Action** to add the users received from Airtable. There are two options for this:
- **Make's Softr module;**
- **Custom HTTPrequest.**
Let's consider each option separately.
2. **Configuring the Action**
In this case, we need to create a new module, search for **HTTP**, select it, and choose the **Make a request** action.
_Selecting the action_
Now, let's start configuring the module based on our [endpoint](/softr-api/tTFQ5vSAUozj5MsKixMH8C/api-setup-and-endpoints/j1PrTZxt7pv3iZCnZ5Fp19). First we need to add our **URL**, then select the **method** (POST), and finally add the required **headers**. We don't need to add the **Content-Type** header, as it's going to be added in the next step. Below, you can see what it should look like.
_Configuring URL, Method, and Headers_
Further on, we need to set the **Body Type** to **Raw** and the **Content Type to JSON**. Lastly, we are going to fill in the **Request Content** using the format provided above. Please, note that the **Parse response** option should be set to **Yes**.
_Configuring Body and Content types and adding Request content_
3. **Testing the Scenario**
So, we're almost there. Let's just add a new record in our table and run the scenario to test it. As, you can see below, the user is successfully added to our Softr app.
> **Tip**
>
> This is optional, but we are also going to [connect our Softr users base](/add-and-manage-users/pxnkp9H3qyEVMF6XUceqnj/syncing-users-with-a-data-source/hshRGygHr4T33EnaLntGf9) to the same [Airtable](/f001252ed01e495d8c0f8e2588f06107) base and table at the beginning to sync user data **from** **Softr to Airtable** as well. This way, the magiclink that's been generated when fetching the user **from Airtable to Softr** will be stored in Softr and eventually **synced back to Airtable**.
_Testing the scenario_
## Deleting a User
The [delete request](/softr-api/tTFQ5vSAUozj5MsKixMH8C/api-setup-and-endpoints/j1PrTZxt7pv3iZCnZ5Fp19) can be implemented in a similar way through an HTTP (Make a request) module.
---
# Softr Database API
Source: https://docs.softr.io/softr-api/softr-database-api
The Softr Database API lets you integrate your Softr data with external systems. The API follows REST semantics, uses JSON to encode objects, and requires all requests to be made over HTTPS.
Download the [OpenAPI specification](/openapi.yaml) to import into tools like Postman or use for code generation.
## Video Introduction
## Data Model
The API is organized around four core resources:
- **Database** — A top-level container that belongs to a workspace. Each database holds one or more tables.
- **Table** — A structured collection of records, similar to a spreadsheet or database table. Each table has a set of fields and one or more views.
- **Field** — A column definition on a table. Fields have a type (e.g. `SINGLE_LINE_TEXT`, `NUMBER`, `SELECT`) and optional configuration. Some fields are read-only (computed or system-managed).
- **Record** — A single row of data in a table. Record values are stored in a `fields` object, keyed by field ID. Responses can use field names instead (`?fieldNames=true`); requests always use field IDs.
Every resource is identified by its ID.
## Authentication
All requests require a **Personal Access Token (PAT)** passed in the `Softr-Api-Key` header:
```bash
curl -X GET 'https://tables-api.softr.io/api/v1/databases' \
-H 'Softr-Api-Key: '
```
Tokens are scoped to one or more workspaces — you can only access databases within your authorized workspaces. See [Authorisation](/softr-api/softr-database-api/authorisation) for how to generate a token.
## Quick Start
**1. List your databases:**
```bash
curl -X GET 'https://tables-api.softr.io/api/v1/databases' \
-H 'Softr-Api-Key: '
```
**2. Get records from a table:**
```bash
curl -X GET 'https://tables-api.softr.io/api/v1/databases/{databaseId}/tables/{tableId}/records?limit=10&fieldNames=true' \
-H 'Softr-Api-Key: '
```
**3. Create a record** (the keys are field IDs; [Get Single Table](/softr-api/softr-database-api/tables/get-single-table) lists a table's fields with their IDs):
```bash
curl -X POST 'https://tables-api.softr.io/api/v1/databases/{databaseId}/tables/{tableId}/records' \
-H 'Softr-Api-Key: ' \
-H 'Content-Type: application/json' \
-d '{
"fields": {
"": "Jane Doe",
"": "jane@example.com"
}
}'
```
## Response Format
### Success (single item)
```json
{
"data": { ... },
"metadata": null
}
```
### Success (paginated list)
```json
{
"data": [ ... ],
"metadata": {
"offset": 0,
"limit": 20,
"total": 100
}
}
```
### Error
```json
{
"message": "Human-readable error message",
"errorCode": "MACHINE_READABLE_CODE",
"details": {
"fieldId": "Additional context",
"traceId": "abc-123"
}
}
```
## Error Codes
| Code | HTTP Status | Description |
| ---------------------- | ----------- | ------------------------------------------------------- |
| `BAD_REQUEST` | 400 | Invalid request format or data |
| `VALIDATION_ERROR` | 400 | Field validation failed |
| `UNKNOWN_FIELD` | 400 | Unrecognized field in request |
| `UNAUTHORIZED` | 401 | Missing or invalid token |
| `QUOTA_EXCEEDED` | 402 | Plan quota limit reached |
| `FORBIDDEN` | 403 | Insufficient permissions |
| `RESOURCE_NOT_FOUND` | 404 | Resource does not exist |
| `CONSTRAINT_VIOLATION` | 409 | Data constraint violation (e.g. duplicate unique value) |
| `PAYLOAD_TOO_LARGE` | 413 | Request body exceeds 64 MB |
| `TOO_MANY_REQUESTS` | 429 | Rate limit exceeded |
| `SERVICE_UNAVAILABLE` | 503 | Service temporarily unavailable |
## Pagination
All list endpoints support offset-based pagination:
| Parameter | Default | Max | Description |
| --------- | ------- | ----- | -------------------------- |
| `offset` | `0` | — | Number of records to skip |
| `limit` | `20` | `200` | Number of records per page |
The response `metadata` includes a `total` count. To iterate through all records:
```
GET .../records?offset=0&limit=100 → records 1–100
GET .../records?offset=100&limit=100 → records 101–200
GET .../records?offset=200&limit=100 → records 201–300
```
Stop when `offset >= metadata.total`.
## Using Field Names
By default, the `fields` object in record responses uses **field IDs** as keys. Pass `?fieldNames=true` on any record endpoint to get **human-readable field names** in the response instead:
```bash
# With field IDs (default)
GET .../records
→ { "fields": { "fld_abc123": "Jane Doe" } }
# With field names
GET .../records?fieldNames=true
→ { "fields": { "Full Name": "Jane Doe" } }
```
`fieldNames` changes the response only. The `fields` of a create or update request and the field references of a
search (`leftSide`, `sortingField`) always take field IDs; a field name there fails with `Unknown field`.
## Quick Links
- [Authorisation](/softr-api/softr-database-api/authorisation)
- [Rate Limiting](/softr-api/softr-database-api/rate-limiting)
- [Databases](/softr-api/softr-database-api/databases/get-databases)
- [Tables](/softr-api/softr-database-api/tables/get-tables)
- [Table Fields](/softr-api/softr-database-api/table-fields/get-table-field)
- [Records](/softr-api/softr-database-api/records/get-records)
- [Search & Filtering](/softr-api/softr-database-api/records/search-records)
---
# Authorisation
Source: https://docs.softr.io/softr-api/softr-database-api/authorisation
All API requests must be authenticated and made over HTTPS.
## Base URL
```
https://tables-api.softr.io/api/v1
```
## Authentication
Pass your Personal Access Token (PAT) in the `Softr-Api-Key` header:
```bash
curl -X GET 'https://tables-api.softr.io/api/v1/databases' \
-H 'Softr-Api-Key: '
```
To generate a token, go to [API Setup and Endpoints](/softr-api/api-setup-and-endpoints).
## Token Scoping
- Tokens are scoped to one or more **workspaces**. You can only access databases within your authorized workspaces.
- The token inherits the access rights of the user who created it.
- We currently support Personal Access Tokens only. OAuth access tokens may be supported in the future.
---
# Rate Limiting
Source: https://docs.softr.io/softr-api/softr-database-api/rate-limiting
All API calls are subject to rate limiting, enforced per token.
| Operation Type | Limit |
| --------------------------------------------- | ------------------ |
| **Reads** (`GET`, `POST /search`) | 40 requests/second |
| **Writes** (`POST`, `PUT`, `PATCH`, `DELETE`) | 30 requests/second |
When the limit is exceeded, the API returns a `429 Too Many Requests` HTTP status code. Back off and retry after a short delay.
---
# Get Databases
Source: https://docs.softr.io/softr-api/softr-database-api/databases/get-databases
## Endpoint
`GET https://tables-api.softr.io/api/v1/databases`
Retrieve a list of all databases accessible to the authenticated user.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Responses
### 200: A list of databases.
- `data` (object[])
- `data.id` (string)
- `data.name` (string)
- `data.description` (string | null)
- `data.workspaceId` (string)
- `data.tablesCount` (integer): Number of tables in this database.
- `data.createdAt` (string)
- `data.updatedAt` (string)
```json
{
"data": [
{
"id": "",
"name": "",
"description": "",
"workspaceId": "",
"tablesCount": 123,
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
]
}
```
### 429: Rate limit exceeded.
- `message` (string): A human-readable error message.
- `errorCode` (string): A machine-readable error code (e.g. BAD_REQUEST, VALIDATION_ERROR, RESOURCE_NOT_FOUND).
- `details` (Record): Additional context about the error (e.g. fieldId, traceId).
```json
{
"message": "",
"errorCode": "",
"details": {}
}
```
## Request example
```bash
curl --request GET \
--url 'https://tables-api.softr.io/api/v1/databases' \
--header 'Softr-Api-Key: '
```
---
# Get Single Database
Source: https://docs.softr.io/softr-api/softr-database-api/databases/get-single-database
## Endpoint
`GET https://tables-api.softr.io/api/v1/databases/{databaseId}`
Retrieve details of a specific database by its ID.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
## Responses
### 200: Database details.
- `data` (object)
- `data.id` (string)
- `data.name` (string)
- `data.description` (string | null)
- `data.workspaceId` (string)
- `data.tablesCount` (integer): Number of tables in this database.
- `data.createdAt` (string)
- `data.updatedAt` (string)
```json
{
"data": {
"id": "",
"name": "",
"description": "",
"workspaceId": "",
"tablesCount": 123,
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
}
```
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request GET \
--url 'https://tables-api.softr.io/api/v1/databases/' \
--header 'Softr-Api-Key: '
```
---
# Create a Database
Source: https://docs.softr.io/softr-api/softr-database-api/databases/create-a-database
## Endpoint
`POST https://tables-api.softr.io/api/v1/databases`
Create a new database in the specified workspace.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Body (application/json)
- `workspaceId` (string, required)
- `name` (string, required)
- `description` (string)
## Responses
### 200: The newly created database.
- `data` (object)
- `data.id` (string)
- `data.name` (string)
- `data.description` (string | null)
- `data.workspaceId` (string)
- `data.tablesCount` (integer): Number of tables in this database.
- `data.createdAt` (string)
- `data.updatedAt` (string)
```json
{
"data": {
"id": "",
"name": "",
"description": "",
"workspaceId": "",
"tablesCount": 123,
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
}
```
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request POST \
--url 'https://tables-api.softr.io/api/v1/databases' \
--header 'Softr-Api-Key: ' \
--header 'Content-Type: application/json' \
--data '{
"workspaceId": "",
"name": ""
}'
```
---
# Update Database
Source: https://docs.softr.io/softr-api/softr-database-api/databases/update-database
## Endpoint
`PUT https://tables-api.softr.io/api/v1/databases/{databaseId}`
Update the details of an existing database.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
## Body (application/json)
- `name` (string)
- `description` (string)
## Responses
### 200: The updated database.
- `data` (object)
- `data.id` (string)
- `data.name` (string)
- `data.description` (string | null)
- `data.workspaceId` (string)
- `data.tablesCount` (integer): Number of tables in this database.
- `data.createdAt` (string)
- `data.updatedAt` (string)
```json
{
"data": {
"id": "",
"name": "",
"description": "",
"workspaceId": "",
"tablesCount": 123,
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
}
```
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request PUT \
--url 'https://tables-api.softr.io/api/v1/databases/' \
--header 'Softr-Api-Key: ' \
--header 'Content-Type: application/json' \
--data '{
"name": "",
"description": ""
}'
```
---
# Delete Database
Source: https://docs.softr.io/softr-api/softr-database-api/databases/delete-database
## Endpoint
`DELETE https://tables-api.softr.io/api/v1/databases/{databaseId}`
Delete a specific database by its ID. It can only be deleted if it is empty, unless the 'force' parameter is used.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
## Query parameters
- `force` (boolean, default: false)
## Responses
### 204: Database deleted successfully.
No response body.
### 400: Bad Request - Database is not empty and force=true was not provided.
No response body.
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request DELETE \
--url 'https://tables-api.softr.io/api/v1/databases/' \
--header 'Softr-Api-Key: '
```
---
# Get Tables
Source: https://docs.softr.io/softr-api/softr-database-api/tables/get-tables
## Endpoint
`GET https://tables-api.softr.io/api/v1/databases/{databaseId}/tables`
Retrieve a list of all tables in the specified database.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
## Responses
### 200: A list of tables.
- `data` (object[])
- `data.id` (string)
- `data.name` (string)
- `data.description` (string | null)
- `data.primaryFieldId` (string)
- `data.defaultViewId` (string)
- `data.fields` (object[])
- `data.fields.id` (string)
- `data.fields.name` (string)
- `data.fields.description` (string | null): Optional description of the field.
- `data.fields.type` (enum): The type of the field. One of: `SINGLE_LINE_TEXT`, `CHECKBOX`, `CURRENCY`, `DATE`, `DATETIME`, `DURATION`, `EMAIL`, `SELECT`, `NUMBER`, `ATTACHMENT`, `RATING`, `LINKED_RECORD`, `LONG_TEXT`, `URL`, `PERCENT`, `PHONE`, `LOOKUP`, `ROLLUP`, `FORMULA`, `CREATED_AT`, `UPDATED_AT`, `CREATED_BY`, `UPDATED_BY`, `AUTONUMBER`, `RECORD_ID`, `USER`.
- `data.fields.options` (Record): Configuration options for the field, specific to its type. See the official documentation for the structure of each type.
- `data.fields.allowMultipleEntries` (boolean)
- `data.fields.readonly` (boolean)
- `data.fields.required` (boolean)
- `data.fields.locked` (boolean)
- `data.fields.defaultValue` (string | null)
- `data.fields.aiOptions` (object | null): AI-powered auto-fill configuration. Null if not configured.
- `data.fields.aiOptions.aiFillable` (boolean)
- `data.fields.aiOptions.aiOnly` (boolean)
- `data.fields.aiOptions.allowWebSearch` (boolean)
- `data.fields.aiOptions.aiModel` (string)
- `data.fields.aiOptions.prompt` (string)
- `data.fields.aiOptions.canBeTriggeredManually` (boolean)
- `data.fields.aiOptions.runWhenRecordIsCreated` (boolean)
- `data.fields.aiOptions.runWhenRecordIsUpdated` (boolean)
- `data.fields.createdAt` (string)
- `data.fields.updatedAt` (string)
- `data.createdAt` (string)
- `data.updatedAt` (string)
```json
{
"data": [
{
"id": "",
"name": "",
"description": "",
"primaryFieldId": "",
"defaultViewId": "",
"fields": [
{
"id": "",
"name": "",
"description": "",
"type": "SINGLE_LINE_TEXT",
"options": {},
"allowMultipleEntries": true,
"readonly": true,
"required": true,
"locked": true,
"defaultValue": "",
"aiOptions": {
"aiFillable": true,
"aiOnly": true,
"allowWebSearch": true,
"aiModel": "",
"prompt": "",
"canBeTriggeredManually": true,
"runWhenRecordIsCreated": true,
"runWhenRecordIsUpdated": true
},
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
],
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
]
}
```
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request GET \
--url 'https://tables-api.softr.io/api/v1/databases//tables' \
--header 'Softr-Api-Key: '
```
---
# Get Single Table
Source: https://docs.softr.io/softr-api/softr-database-api/tables/get-single-table
## Endpoint
`GET https://tables-api.softr.io/api/v1/databases/{databaseId}/tables/{tableId}`
Retrieve details of a specific table by its ID.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
- `tableId` (string, required)
## Responses
### 200: Table details.
- `data` (object)
- `data.id` (string)
- `data.name` (string)
- `data.description` (string | null)
- `data.primaryFieldId` (string)
- `data.defaultViewId` (string)
- `data.fields` (object[])
- `data.fields.id` (string)
- `data.fields.name` (string)
- `data.fields.description` (string | null): Optional description of the field.
- `data.fields.type` (enum): The type of the field. One of: `SINGLE_LINE_TEXT`, `CHECKBOX`, `CURRENCY`, `DATE`, `DATETIME`, `DURATION`, `EMAIL`, `SELECT`, `NUMBER`, `ATTACHMENT`, `RATING`, `LINKED_RECORD`, `LONG_TEXT`, `URL`, `PERCENT`, `PHONE`, `LOOKUP`, `ROLLUP`, `FORMULA`, `CREATED_AT`, `UPDATED_AT`, `CREATED_BY`, `UPDATED_BY`, `AUTONUMBER`, `RECORD_ID`, `USER`.
- `data.fields.options` (Record): Configuration options for the field, specific to its type. See the official documentation for the structure of each type.
- `data.fields.allowMultipleEntries` (boolean)
- `data.fields.readonly` (boolean)
- `data.fields.required` (boolean)
- `data.fields.locked` (boolean)
- `data.fields.defaultValue` (string | null)
- `data.fields.aiOptions` (object | null): AI-powered auto-fill configuration. Null if not configured.
- `data.fields.aiOptions.aiFillable` (boolean)
- `data.fields.aiOptions.aiOnly` (boolean)
- `data.fields.aiOptions.allowWebSearch` (boolean)
- `data.fields.aiOptions.aiModel` (string)
- `data.fields.aiOptions.prompt` (string)
- `data.fields.aiOptions.canBeTriggeredManually` (boolean)
- `data.fields.aiOptions.runWhenRecordIsCreated` (boolean)
- `data.fields.aiOptions.runWhenRecordIsUpdated` (boolean)
- `data.fields.createdAt` (string)
- `data.fields.updatedAt` (string)
- `data.createdAt` (string)
- `data.updatedAt` (string)
```json
{
"data": {
"id": "",
"name": "",
"description": "",
"primaryFieldId": "",
"defaultViewId": "",
"fields": [
{
"id": "",
"name": "",
"description": "",
"type": "SINGLE_LINE_TEXT",
"options": {},
"allowMultipleEntries": true,
"readonly": true,
"required": true,
"locked": true,
"defaultValue": "",
"aiOptions": {
"aiFillable": true,
"aiOnly": true,
"allowWebSearch": true,
"aiModel": "",
"prompt": "",
"canBeTriggeredManually": true,
"runWhenRecordIsCreated": true,
"runWhenRecordIsUpdated": true
},
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
],
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
}
```
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request GET \
--url 'https://tables-api.softr.io/api/v1/databases//tables/' \
--header 'Softr-Api-Key: '
```
---
# Get Table Views
Source: https://docs.softr.io/softr-api/softr-database-api/tables/get-table-views
## Endpoint
`GET https://tables-api.softr.io/api/v1/databases/{databaseId}/tables/{tableId}/views`
Retrieve a list of views for a specific table.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
- `tableId` (string, required)
## Responses
### 200: A list of table views.
- `data` (object[])
- `data.id` (string)
- `data.tableId` (string)
- `data.name` (string)
- `data.description` (string | null)
- `data.createdAt` (string)
- `data.updatedAt` (string)
```json
{
"data": [
{
"id": "",
"tableId": "",
"name": "",
"description": "",
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
]
}
```
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request GET \
--url 'https://tables-api.softr.io/api/v1/databases//tables//views' \
--header 'Softr-Api-Key: '
```
---
# Create Table
Source: https://docs.softr.io/softr-api/softr-database-api/tables/create-table
## Endpoint
`POST https://tables-api.softr.io/api/v1/databases/{databaseId}/tables`
Create a new table in the specified database.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
## Body (application/json)
- `name` (string)
- `description` (string)
- `primaryFieldName` (string)
- `fields` (object[])
- `fields.name` (string)
- `fields.type` (string)
- `fields.options` (Record)
## Responses
### 200: The newly created table.
- `data` (object)
- `data.id` (string)
- `data.name` (string)
- `data.description` (string | null)
- `data.primaryFieldId` (string)
- `data.defaultViewId` (string)
- `data.fields` (object[])
- `data.fields.id` (string)
- `data.fields.name` (string)
- `data.fields.description` (string | null): Optional description of the field.
- `data.fields.type` (enum): The type of the field. One of: `SINGLE_LINE_TEXT`, `CHECKBOX`, `CURRENCY`, `DATE`, `DATETIME`, `DURATION`, `EMAIL`, `SELECT`, `NUMBER`, `ATTACHMENT`, `RATING`, `LINKED_RECORD`, `LONG_TEXT`, `URL`, `PERCENT`, `PHONE`, `LOOKUP`, `ROLLUP`, `FORMULA`, `CREATED_AT`, `UPDATED_AT`, `CREATED_BY`, `UPDATED_BY`, `AUTONUMBER`, `RECORD_ID`, `USER`.
- `data.fields.options` (Record): Configuration options for the field, specific to its type. See the official documentation for the structure of each type.
- `data.fields.allowMultipleEntries` (boolean)
- `data.fields.readonly` (boolean)
- `data.fields.required` (boolean)
- `data.fields.locked` (boolean)
- `data.fields.defaultValue` (string | null)
- `data.fields.aiOptions` (object | null): AI-powered auto-fill configuration. Null if not configured.
- `data.fields.aiOptions.aiFillable` (boolean)
- `data.fields.aiOptions.aiOnly` (boolean)
- `data.fields.aiOptions.allowWebSearch` (boolean)
- `data.fields.aiOptions.aiModel` (string)
- `data.fields.aiOptions.prompt` (string)
- `data.fields.aiOptions.canBeTriggeredManually` (boolean)
- `data.fields.aiOptions.runWhenRecordIsCreated` (boolean)
- `data.fields.aiOptions.runWhenRecordIsUpdated` (boolean)
- `data.fields.createdAt` (string)
- `data.fields.updatedAt` (string)
- `data.createdAt` (string)
- `data.updatedAt` (string)
```json
{
"data": {
"id": "",
"name": "",
"description": "",
"primaryFieldId": "",
"defaultViewId": "",
"fields": [
{
"id": "",
"name": "",
"description": "",
"type": "SINGLE_LINE_TEXT",
"options": {},
"allowMultipleEntries": true,
"readonly": true,
"required": true,
"locked": true,
"defaultValue": "",
"aiOptions": {
"aiFillable": true,
"aiOnly": true,
"allowWebSearch": true,
"aiModel": "",
"prompt": "",
"canBeTriggeredManually": true,
"runWhenRecordIsCreated": true,
"runWhenRecordIsUpdated": true
},
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
],
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
}
```
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request POST \
--url 'https://tables-api.softr.io/api/v1/databases//tables' \
--header 'Softr-Api-Key: ' \
--header 'Content-Type: application/json' \
--data '{
"name": "",
"description": "",
"primaryFieldName": "",
"fields": [
{
"name": "",
"type": "",
"options": {}
}
]
}'
```
---
# Update Table
Source: https://docs.softr.io/softr-api/softr-database-api/tables/update-table
## Endpoint
`PUT https://tables-api.softr.io/api/v1/databases/{databaseId}/tables/{tableId}`
Update a table's name and/or description. To modify fields, use the field-specific endpoints.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
- `tableId` (string, required)
## Body (application/json)
- `name` (string)
- `description` (string)
## Responses
### 200: The updated table.
- `data` (object)
- `data.id` (string)
- `data.name` (string)
- `data.description` (string | null)
- `data.primaryFieldId` (string)
- `data.defaultViewId` (string)
- `data.fields` (object[])
- `data.fields.id` (string)
- `data.fields.name` (string)
- `data.fields.description` (string | null): Optional description of the field.
- `data.fields.type` (enum): The type of the field. One of: `SINGLE_LINE_TEXT`, `CHECKBOX`, `CURRENCY`, `DATE`, `DATETIME`, `DURATION`, `EMAIL`, `SELECT`, `NUMBER`, `ATTACHMENT`, `RATING`, `LINKED_RECORD`, `LONG_TEXT`, `URL`, `PERCENT`, `PHONE`, `LOOKUP`, `ROLLUP`, `FORMULA`, `CREATED_AT`, `UPDATED_AT`, `CREATED_BY`, `UPDATED_BY`, `AUTONUMBER`, `RECORD_ID`, `USER`.
- `data.fields.options` (Record): Configuration options for the field, specific to its type. See the official documentation for the structure of each type.
- `data.fields.allowMultipleEntries` (boolean)
- `data.fields.readonly` (boolean)
- `data.fields.required` (boolean)
- `data.fields.locked` (boolean)
- `data.fields.defaultValue` (string | null)
- `data.fields.aiOptions` (object | null): AI-powered auto-fill configuration. Null if not configured.
- `data.fields.aiOptions.aiFillable` (boolean)
- `data.fields.aiOptions.aiOnly` (boolean)
- `data.fields.aiOptions.allowWebSearch` (boolean)
- `data.fields.aiOptions.aiModel` (string)
- `data.fields.aiOptions.prompt` (string)
- `data.fields.aiOptions.canBeTriggeredManually` (boolean)
- `data.fields.aiOptions.runWhenRecordIsCreated` (boolean)
- `data.fields.aiOptions.runWhenRecordIsUpdated` (boolean)
- `data.fields.createdAt` (string)
- `data.fields.updatedAt` (string)
- `data.createdAt` (string)
- `data.updatedAt` (string)
```json
{
"data": {
"id": "",
"name": "",
"description": "",
"primaryFieldId": "",
"defaultViewId": "",
"fields": [
{
"id": "",
"name": "",
"description": "",
"type": "SINGLE_LINE_TEXT",
"options": {},
"allowMultipleEntries": true,
"readonly": true,
"required": true,
"locked": true,
"defaultValue": "",
"aiOptions": {
"aiFillable": true,
"aiOnly": true,
"allowWebSearch": true,
"aiModel": "",
"prompt": "",
"canBeTriggeredManually": true,
"runWhenRecordIsCreated": true,
"runWhenRecordIsUpdated": true
},
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
],
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
}
```
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request PUT \
--url 'https://tables-api.softr.io/api/v1/databases//tables/' \
--header 'Softr-Api-Key: ' \
--header 'Content-Type: application/json' \
--data '{
"name": "",
"description": ""
}'
```
---
# Delete Table
Source: https://docs.softr.io/softr-api/softr-database-api/tables/delete-table
## Endpoint
`DELETE https://tables-api.softr.io/api/v1/databases/{databaseId}/tables/{tableId}`
Delete a specific table by its ID. It can only be deleted if it is empty, unless the 'force' parameter is used.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
- `tableId` (string, required)
## Query parameters
- `force` (boolean, default: false)
## Responses
### 204: Table deleted successfully.
No response body.
### 400: Bad Request - Table is not empty and force=true was not provided.
No response body.
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request DELETE \
--url 'https://tables-api.softr.io/api/v1/databases//tables/' \
--header 'Softr-Api-Key: '
```
---
# Get Table Field
Source: https://docs.softr.io/softr-api/softr-database-api/table-fields/get-table-field
## Endpoint
`GET https://tables-api.softr.io/api/v1/databases/{databaseId}/tables/{tableId}/fields/{fieldId}`
Retrieve details of a specific field.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
- `tableId` (string, required)
- `fieldId` (string, required)
## Responses
### 200: Field details.
- `data` (object)
- `data.id` (string)
- `data.name` (string)
- `data.description` (string | null): Optional description of the field.
- `data.type` (enum): The type of the field. One of: `SINGLE_LINE_TEXT`, `CHECKBOX`, `CURRENCY`, `DATE`, `DATETIME`, `DURATION`, `EMAIL`, `SELECT`, `NUMBER`, `ATTACHMENT`, `RATING`, `LINKED_RECORD`, `LONG_TEXT`, `URL`, `PERCENT`, `PHONE`, `LOOKUP`, `ROLLUP`, `FORMULA`, `CREATED_AT`, `UPDATED_AT`, `CREATED_BY`, `UPDATED_BY`, `AUTONUMBER`, `RECORD_ID`, `USER`.
- `data.options` (Record): Configuration options for the field, specific to its type. See the official documentation for the structure of each type.
- `data.allowMultipleEntries` (boolean)
- `data.readonly` (boolean)
- `data.required` (boolean)
- `data.locked` (boolean)
- `data.defaultValue` (string | null)
- `data.aiOptions` (object | null): AI-powered auto-fill configuration. Null if not configured.
- `data.aiOptions.aiFillable` (boolean)
- `data.aiOptions.aiOnly` (boolean)
- `data.aiOptions.allowWebSearch` (boolean)
- `data.aiOptions.aiModel` (string)
- `data.aiOptions.prompt` (string)
- `data.aiOptions.canBeTriggeredManually` (boolean)
- `data.aiOptions.runWhenRecordIsCreated` (boolean)
- `data.aiOptions.runWhenRecordIsUpdated` (boolean)
- `data.createdAt` (string)
- `data.updatedAt` (string)
```json
{
"data": {
"id": "",
"name": "",
"description": "",
"type": "SINGLE_LINE_TEXT",
"options": {},
"allowMultipleEntries": true,
"readonly": true,
"required": true,
"locked": true,
"defaultValue": "",
"aiOptions": {
"aiFillable": true,
"aiOnly": true,
"allowWebSearch": true,
"aiModel": "",
"prompt": "",
"canBeTriggeredManually": true,
"runWhenRecordIsCreated": true,
"runWhenRecordIsUpdated": true
},
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
}
```
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request GET \
--url 'https://tables-api.softr.io/api/v1/databases//tables//fields/' \
--header 'Softr-Api-Key: '
```
---
# Add Table Field
Source: https://docs.softr.io/softr-api/softr-database-api/table-fields/add-table-field
## Field Types Reference
### Editable Fields
| Type | Value Format | Description |
| ------------------ | ------------------- | ---------------------------------------------- |
| `SINGLE_LINE_TEXT` | `string` | Short text |
| `LONG_TEXT` | `string` | Multi-line text |
| `EMAIL` | `string` | Email address |
| `PHONE` | `string` | Phone number |
| `URL` | `string` | Web URL |
| `NUMBER` | `number` | Numeric value |
| `CURRENCY` | `number` | Monetary amount |
| `PERCENT` | `number` | Percentage (0–100) |
| `RATING` | `number` | Star rating |
| `DURATION` | `number` | Duration |
| `CHECKBOX` | `boolean` | True/false |
| `SELECT` | `string` or `array` | Single or multi-select from predefined choices |
| `USER` | `object` or `array` | User reference |
| `LINKED_RECORD` | `string` or `array` | Link to record(s) in another table |
| `ATTACHMENT` | `object` or `array` | File attachment |
| `DATE` | `string` | Date (ISO 8601) |
| `DATETIME` | `string` | Date and time (ISO 8601) |
### Read-Only Fields
These are computed or system-managed and cannot be set when creating or updating records.
| Type | Description |
| ------------ | ------------------------------------ |
| `LOOKUP` | Value from a linked record's field |
| `ROLLUP` | Aggregation over linked records |
| `FORMULA` | Calculated from a formula expression |
| `CREATED_AT` | Record creation timestamp |
| `UPDATED_AT` | Record last modified timestamp |
| `CREATED_BY` | User who created the record |
| `UPDATED_BY` | User who last modified the record |
| `AUTONUMBER` | Auto-incrementing number |
| `RECORD_ID` | System record identifier |
## Field Options
Type-specific configuration passed in the `options` object when creating or updating fields.
### SELECT
```json
{
"choices": [
{ "id": "choice-1", "label": "Option A", "color": "#FF0000" },
{ "id": "choice-2", "label": "Option B", "color": "#00FF00" }
],
"allowToAddNewChoice": true,
"sorting": "CUSTOM",
"enforceOrder": false
}
```
`sorting` can be `CUSTOM`, `ALPHA_ASC`, or `ALPHA_DESC`.
### NUMBER
```json
{
"precision": 2,
"min": 0,
"max": 1000000,
"showThousandSeparator": true,
"thousandSeparatorLocale": "en-US",
"largeNumberAbbreviation": "NONE",
"prefix": null,
"suffix": null
}
```
`largeNumberAbbreviation` can be `NONE`, `K`, `M`, `B`, or `T`.
### CURRENCY
```json
{
"precision": 2,
"min": null,
"max": null,
"isoCode": "USD",
"customSymbol": null,
"showAs": "SYMBOL",
"showThousandSeparator": true,
"thousandSeparatorLocale": "en-US",
"largeNumberAbbreviation": "NONE",
"symbolOrCodePosition": "BEFORE"
}
```
- `showAs`: `SYMBOL` or `CODE`
- `symbolOrCodePosition`: `BEFORE` or `AFTER`
### LINKED\_RECORD
```json
{
"linkedTableId": "table-uuid",
"inverseLinkFieldId": "field-uuid",
"viewId": null,
"sorting": [],
"filter": null,
"enforceOrder": false
}
```
### LOOKUP
```json
{
"linkedRecordFieldId": "field-uuid",
"lookupFieldId": "field-uuid",
"isValid": true
}
```
### ROLLUP
```json
{
"linkedRecordFieldId": "field-uuid",
"rollupFieldId": "field-uuid",
"function": "SUM",
"filter": null
}
```
Available functions: `SUM`, `MIN`, `MAX`, `COUNT`, `AVERAGE`, `ARRAYCOMPACT`, `ARRAYJOIN`, `ARRAYUNIQUE`, `ARRAYFLATTEN`, `CONCATENATE`, `COUNTALL`, `COUNTA`, `OR`, `AND`.
### ATTACHMENT
```json
{
"showAs": "PREVIEW",
"inferredFileType": "OTHER",
"enableFileLinkExpiration": true,
"fileLinkExpirationValue": 2,
"fileLinkExpirationUnit": "HOURS"
}
```
- `showAs`: `PREVIEW`, `LIST`, or `BADGE`
- `inferredFileType`: `IMAGE`, `VIDEO`, `PDF`, `AUDIO`, or `OTHER`
- `fileLinkExpirationUnit`: `HOURS` or `MINUTES`
### FORMULA
```json
{
"formula": "IF({Status} = 'Active', {Amount} * 1.1, {Amount})",
"isValid": true,
"referencedFieldIds": ["field-uuid-1", "field-uuid-2"]
}
```
## AI Options
Fields can include an `aiOptions` object that configures AI-powered auto-fill behavior. This is returned in field definitions and can be set when creating or updating fields.
```json
{
"aiFillable": true,
"aiOnly": false,
"allowWebSearch": true,
"aiModel": "GPT_4_1",
"prompt": "Summarize the customer's request based on {Description}",
"canBeTriggeredManually": true,
"runWhenRecordIsCreated": true,
"runWhenRecordIsUpdated": false
}
```
| Property | Type | Default | Description |
| ------------------------ | ------- | ----------- | ----------------------------------------------------------- |
| `aiFillable` | boolean | `false` | Whether AI can fill this field |
| `aiOnly` | boolean | `true` | If `true`, only AI can write to this field |
| `allowWebSearch` | boolean | `false` | Allow AI to use web search when filling |
| `aiModel` | string | `"GPT_4_1"` | AI model to use |
| `prompt` | string | `""` | Prompt template (reference other fields with `{FieldName}`) |
| `canBeTriggeredManually` | boolean | `true` | Whether users can trigger AI fill manually |
| `runWhenRecordIsCreated` | boolean | `true` | Auto-run when record is created |
| `runWhenRecordIsUpdated` | boolean | `true` | Auto-run when record is updated |
Fields without AI configuration return `"aiOptions": null`.
## Endpoint
`POST https://tables-api.softr.io/api/v1/databases/{databaseId}/tables/{tableId}/fields`
Add a new field to a table.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
- `tableId` (string, required)
## Body (application/json)
- `name` (string, required)
- `type` (string, required)
- `options` (Record)
## Responses
### 200: The newly created field.
- `data` (object)
- `data.id` (string)
- `data.name` (string)
- `data.description` (string | null): Optional description of the field.
- `data.type` (enum): The type of the field. One of: `SINGLE_LINE_TEXT`, `CHECKBOX`, `CURRENCY`, `DATE`, `DATETIME`, `DURATION`, `EMAIL`, `SELECT`, `NUMBER`, `ATTACHMENT`, `RATING`, `LINKED_RECORD`, `LONG_TEXT`, `URL`, `PERCENT`, `PHONE`, `LOOKUP`, `ROLLUP`, `FORMULA`, `CREATED_AT`, `UPDATED_AT`, `CREATED_BY`, `UPDATED_BY`, `AUTONUMBER`, `RECORD_ID`, `USER`.
- `data.options` (Record): Configuration options for the field, specific to its type. See the official documentation for the structure of each type.
- `data.allowMultipleEntries` (boolean)
- `data.readonly` (boolean)
- `data.required` (boolean)
- `data.locked` (boolean)
- `data.defaultValue` (string | null)
- `data.aiOptions` (object | null): AI-powered auto-fill configuration. Null if not configured.
- `data.aiOptions.aiFillable` (boolean)
- `data.aiOptions.aiOnly` (boolean)
- `data.aiOptions.allowWebSearch` (boolean)
- `data.aiOptions.aiModel` (string)
- `data.aiOptions.prompt` (string)
- `data.aiOptions.canBeTriggeredManually` (boolean)
- `data.aiOptions.runWhenRecordIsCreated` (boolean)
- `data.aiOptions.runWhenRecordIsUpdated` (boolean)
- `data.createdAt` (string)
- `data.updatedAt` (string)
```json
{
"data": {
"id": "",
"name": "",
"description": "",
"type": "SINGLE_LINE_TEXT",
"options": {},
"allowMultipleEntries": true,
"readonly": true,
"required": true,
"locked": true,
"defaultValue": "",
"aiOptions": {
"aiFillable": true,
"aiOnly": true,
"allowWebSearch": true,
"aiModel": "",
"prompt": "",
"canBeTriggeredManually": true,
"runWhenRecordIsCreated": true,
"runWhenRecordIsUpdated": true
},
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
}
```
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request POST \
--url 'https://tables-api.softr.io/api/v1/databases//tables//fields' \
--header 'Softr-Api-Key: ' \
--header 'Content-Type: application/json' \
--data '{
"name": "",
"type": ""
}'
```
---
# Update Table Field
Source: https://docs.softr.io/softr-api/softr-database-api/table-fields/update-table-field
## Endpoint
`PUT https://tables-api.softr.io/api/v1/databases/{databaseId}/tables/{tableId}/fields/{fieldId}`
Update the properties of a specific field.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
- `tableId` (string, required)
- `fieldId` (string, required)
## Body (application/json)
- `name` (string)
- `type` (string)
- `options` (Record)
## Responses
### 200: The updated field.
- `data` (object)
- `data.id` (string)
- `data.name` (string)
- `data.description` (string | null): Optional description of the field.
- `data.type` (enum): The type of the field. One of: `SINGLE_LINE_TEXT`, `CHECKBOX`, `CURRENCY`, `DATE`, `DATETIME`, `DURATION`, `EMAIL`, `SELECT`, `NUMBER`, `ATTACHMENT`, `RATING`, `LINKED_RECORD`, `LONG_TEXT`, `URL`, `PERCENT`, `PHONE`, `LOOKUP`, `ROLLUP`, `FORMULA`, `CREATED_AT`, `UPDATED_AT`, `CREATED_BY`, `UPDATED_BY`, `AUTONUMBER`, `RECORD_ID`, `USER`.
- `data.options` (Record): Configuration options for the field, specific to its type. See the official documentation for the structure of each type.
- `data.allowMultipleEntries` (boolean)
- `data.readonly` (boolean)
- `data.required` (boolean)
- `data.locked` (boolean)
- `data.defaultValue` (string | null)
- `data.aiOptions` (object | null): AI-powered auto-fill configuration. Null if not configured.
- `data.aiOptions.aiFillable` (boolean)
- `data.aiOptions.aiOnly` (boolean)
- `data.aiOptions.allowWebSearch` (boolean)
- `data.aiOptions.aiModel` (string)
- `data.aiOptions.prompt` (string)
- `data.aiOptions.canBeTriggeredManually` (boolean)
- `data.aiOptions.runWhenRecordIsCreated` (boolean)
- `data.aiOptions.runWhenRecordIsUpdated` (boolean)
- `data.createdAt` (string)
- `data.updatedAt` (string)
```json
{
"data": {
"id": "",
"name": "",
"description": "",
"type": "SINGLE_LINE_TEXT",
"options": {},
"allowMultipleEntries": true,
"readonly": true,
"required": true,
"locked": true,
"defaultValue": "",
"aiOptions": {
"aiFillable": true,
"aiOnly": true,
"allowWebSearch": true,
"aiModel": "",
"prompt": "",
"canBeTriggeredManually": true,
"runWhenRecordIsCreated": true,
"runWhenRecordIsUpdated": true
},
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
}
```
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request PUT \
--url 'https://tables-api.softr.io/api/v1/databases//tables//fields/' \
--header 'Softr-Api-Key: ' \
--header 'Content-Type: application/json' \
--data '{
"name": "",
"type": "",
"options": {}
}'
```
---
# Delete Table Field
Source: https://docs.softr.io/softr-api/softr-database-api/table-fields/delete-table-field
## Endpoint
`DELETE https://tables-api.softr.io/api/v1/databases/{databaseId}/tables/{tableId}/fields/{fieldId}`
Delete a specific field from a table.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
- `tableId` (string, required)
- `fieldId` (string, required)
## Responses
### 204: Field deleted successfully.
No response body.
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request DELETE \
--url 'https://tables-api.softr.io/api/v1/databases//tables//fields/' \
--header 'Softr-Api-Key: '
```
---
# Get Records
Source: https://docs.softr.io/softr-api/softr-database-api/records/get-records
## Endpoint
`GET https://tables-api.softr.io/api/v1/databases/{databaseId}/tables/{tableId}/records`
Retrieve a list of all records in the specified table.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
- `tableId` (string, required)
## Query parameters
- `offset` (integer, default: 0)
- `limit` (integer, default: 10)
- `fieldNames` (boolean, default: false): If true, use field names as keys in the fields object instead of field IDs.
- `viewId` (string): Filter records by a specific view.
## Responses
### 200: A paginated list of records.
- `data` (object[])
- `data.id` (string)
- `data.tableId` (string)
- `data.fields` (Record): A map of Field IDs to their values for this record.
- `data.createdAt` (string)
- `data.updatedAt` (string)
- `metadata` (object)
- `metadata.offset` (integer)
- `metadata.limit` (integer)
- `metadata.total` (integer)
```json
{
"data": [
{
"id": "",
"tableId": "",
"fields": {},
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
],
"metadata": {
"offset": 123,
"limit": 123,
"total": 123
}
}
```
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request GET \
--url 'https://tables-api.softr.io/api/v1/databases//tables//records' \
--header 'Softr-Api-Key: '
```
---
# Search Records
Source: https://docs.softr.io/softr-api/softr-database-api/records/search-records
## Filtering Guide
The Search Records endpoint lets you filter, sort, and paginate records using a JSON request body. All three top-level fields (`filter`, `sorting`, `paging`) are optional.
```json
{
"paging": {
"offset": 0,
"limit": 50
},
"sorting": [
{ "sortingField": "field-uuid", "sortType": "ASC" }
],
"filter": {
"condition": { ... }
}
}
```
### Filter Condition Types
Filters are passed in `filter.condition`. There are four types, determined by the operator.
#### Binary Conditions
Compare a field to a value:
```json
{
"operator": "CONTAINS",
"leftSide": "field-uuid",
"rightSide": "search term"
}
```
| Operator | Description | Right Side |
| ------------------------ | ----------------------------- | -------------- |
| `IS` | Equals | single value |
| `IS_NOT` | Not equals | single value |
| `GREATER_THAN` | Greater than | number or date |
| `GREATER_THAN_OR_EQUALS` | Greater than or equal | number or date |
| `LESS_THAN` | Less than | number or date |
| `LESS_THAN_OR_EQUALS` | Less than or equal | number or date |
| `CONTAINS` | String contains | string |
| `DOES_NOT_CONTAIN` | String does not contain | string |
| `STARTS_WITH` | String starts with | string |
| `DOES_NOT_START_WITH` | String does not start with | string |
| `ENDS_WITH` | String ends with | string |
| `DOES_NOT_END_WITH` | String does not end with | string |
| `IS_ONE_OF` | Value is one of | array |
| `IS_NOT_ONE_OF` | Value is none of | array |
| `HAS_ANY_OF` | Multi-value field has any of | array |
| `HAS_ALL_OF` | Multi-value field has all of | array |
| `HAS_NONE_OF` | Multi-value field has none of | array |
#### Unary Conditions
Check whether a field is empty — no `rightSide` needed:
```json
{
"operator": "IS_EMPTY",
"leftSide": "field-uuid"
}
```
| Operator | Description |
| -------------- | ------------------ |
| `IS_EMPTY` | Field has no value |
| `IS_NOT_EMPTY` | Field has a value |
#### Ternary Conditions
Range-based checks with `lowerBound` and `upperBound`:
```json
{
"operator": "IS_BETWEEN",
"leftSide": "field-uuid",
"lowerBound": 10,
"upperBound": 100
}
```
| Operator | Description |
| ---------------- | ----------------------------------- |
| `IS_BETWEEN` | Value is between bounds (inclusive) |
| `IS_NOT_BETWEEN` | Value is outside bounds |
| `IS_WITHIN` | Date is within a relative range |
| `IS_NOT_WITHIN` | Date is outside a relative range |
#### Composite Conditions
Combine multiple conditions with `AND` or `OR`:
```json
{
"operator": "AND",
"conditions": [
{ "operator": "CONTAINS", "leftSide": "name-field", "rightSide": "acme" },
{ "operator": "GREATER_THAN", "leftSide": "amount-field", "rightSide": 1000 },
{
"operator": "OR",
"conditions": [
{ "operator": "IS", "leftSide": "status-field", "rightSide": "active" },
{ "operator": "IS_EMPTY", "leftSide": "archived-field" }
]
}
]
}
```
### Relative Date Values
For date fields, you can use relative date strings instead of fixed ISO 8601 dates:
| Format | Examples |
| ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `PREDEFINED:` | `PREDEFINED:TODAY`, `PREDEFINED:YESTERDAY`, `PREDEFINED:TOMORROW`, `PREDEFINED:THIS_WEEK`, `PREDEFINED:LAST_WEEK`, `PREDEFINED:THIS_MONTH`, `PREDEFINED:THIS_YEAR`, `PREDEFINED:NEXT_MONTH`, `PREDEFINED:PAST_MONTH`, `PREDEFINED:7_DAYS_AGO`, `PREDEFINED:30_DAYS_FROM_NOW` |
| `RELATIVE_DATE::` | `RELATIVE_DATE:THIS:WEEK`, `RELATIVE_DATE:PAST:MONTH`, `RELATIVE_DATE:NEXT:QUARTER`, `RELATIVE_DATE:PAST:7` (7 days ago) |
| ISO 8601 | `"2025-05-21"`, `"2025-05-21T20:00:00.000Z"` |
### Complete Example
Find active contacts named "acme" with an amount over 1000, created this month:
```json
{
"paging": { "offset": 0, "limit": 50 },
"sorting": [
{ "sortingField": "amount-field-uuid", "sortType": "DESC" }
],
"filter": {
"condition": {
"operator": "AND",
"conditions": [
{ "operator": "CONTAINS", "leftSide": "name-field-uuid", "rightSide": "acme" },
{ "operator": "GREATER_THAN", "leftSide": "amount-field-uuid", "rightSide": 1000 },
{ "operator": "IS", "leftSide": "status-field-uuid", "rightSide": "active" },
{ "operator": "IS_WITHIN", "leftSide": "created-at-field-uuid", "lowerBound": "RELATIVE_DATE:THIS:MONTH", "upperBound": "PREDEFINED:TODAY" }
]
}
}
}
```
## Endpoint
`POST https://tables-api.softr.io/api/v1/databases/{databaseId}/tables/{tableId}/records/search`
Search for records in the specified table based on filter, sort, and pagination criteria.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
- `tableId` (string, required)
## Query parameters
- `fieldNames` (boolean, default: false): If true, use field names as keys in the fields object instead of field IDs.
## Body (application/json)
- `filter` (object)
- `filter.condition` (object): A condition for filtering records. Text-related conditions are case-insensitive.
- `filter.condition.operator` (enum) One of: `AND`, `OR`, `IS_EMPTY`, `IS_NOT_EMPTY`, `IS_BETWEEN`, `IS_NOT_BETWEEN`, `IS_WITHIN`, `IS_NOT_WITHIN`, `IS`, `IS_NOT`, `GREATER_THAN`, `GREATER_THAN_OR_EQUALS`, `LESS_THAN`, `LESS_THAN_OR_EQUALS`, `CONTAINS`, `DOES_NOT_CONTAIN`, `STARTS_WITH`, `DOES_NOT_START_WITH`, `ENDS_WITH`, `DOES_NOT_END_WITH`, `IS_ONE_OF`, `IS_NOT_ONE_OF`, `HAS_ANY_OF`, `HAS_ALL_OF`, `HAS_NONE_OF`.
- `filter.condition.leftSide` (string): The Field ID to apply the operator on.
- `filter.condition.rightSide` (string | number | boolean | string[]): The value to compare against. Can be a string, number, or an array for operators like IS_ONE_OF.
- `filter.condition.lowerBound` (string): Lower bound for IS_BETWEEN operator.
- `filter.condition.upperBound` (string): Upper bound for IS_BETWEEN operator.
- `filter.condition.conditions` (object[]): Used for AND/OR operators to nest conditions.
- `filter.condition.conditions.operator` (enum) One of: `AND`, `OR`, `IS_EMPTY`, `IS_NOT_EMPTY`, `IS_BETWEEN`, `IS_NOT_BETWEEN`, `IS_WITHIN`, `IS_NOT_WITHIN`, `IS`, `IS_NOT`, `GREATER_THAN`, `GREATER_THAN_OR_EQUALS`, `LESS_THAN`, `LESS_THAN_OR_EQUALS`, `CONTAINS`, `DOES_NOT_CONTAIN`, `STARTS_WITH`, `DOES_NOT_START_WITH`, `ENDS_WITH`, `DOES_NOT_END_WITH`, `IS_ONE_OF`, `IS_NOT_ONE_OF`, `HAS_ANY_OF`, `HAS_ALL_OF`, `HAS_NONE_OF`.
- `filter.condition.conditions.leftSide` (string): The Field ID to apply the operator on.
- `filter.condition.conditions.rightSide` (string | number | boolean | string[]): The value to compare against. Can be a string, number, or an array for operators like IS_ONE_OF.
- `filter.condition.conditions.lowerBound` (string): Lower bound for IS_BETWEEN operator.
- `filter.condition.conditions.upperBound` (string): Upper bound for IS_BETWEEN operator.
- `filter.condition.conditions.conditions` (object[]): Used for AND/OR operators to nest conditions.
- `filter.condition.conditions.conditions.operator` (enum) One of: `AND`, `OR`, `IS_EMPTY`, `IS_NOT_EMPTY`, `IS_BETWEEN`, `IS_NOT_BETWEEN`, `IS_WITHIN`, `IS_NOT_WITHIN`, `IS`, `IS_NOT`, `GREATER_THAN`, `GREATER_THAN_OR_EQUALS`, `LESS_THAN`, `LESS_THAN_OR_EQUALS`, `CONTAINS`, `DOES_NOT_CONTAIN`, `STARTS_WITH`, `DOES_NOT_START_WITH`, `ENDS_WITH`, `DOES_NOT_END_WITH`, `IS_ONE_OF`, `IS_NOT_ONE_OF`, `HAS_ANY_OF`, `HAS_ALL_OF`, `HAS_NONE_OF`.
- `filter.condition.conditions.conditions.leftSide` (string): The Field ID to apply the operator on.
- `filter.condition.conditions.conditions.rightSide` (string | number | boolean | string[]): The value to compare against. Can be a string, number, or an array for operators like IS_ONE_OF.
- `filter.condition.conditions.conditions.lowerBound` (string): Lower bound for IS_BETWEEN operator.
- `filter.condition.conditions.conditions.upperBound` (string): Upper bound for IS_BETWEEN operator.
- `filter.condition.conditions.conditions.conditions` (object[]): Used for AND/OR operators to nest conditions.
- `filter.condition.conditions.conditions.conditions.operator` (enum) One of: `AND`, `OR`, `IS_EMPTY`, `IS_NOT_EMPTY`, `IS_BETWEEN`, `IS_NOT_BETWEEN`, `IS_WITHIN`, `IS_NOT_WITHIN`, `IS`, `IS_NOT`, `GREATER_THAN`, `GREATER_THAN_OR_EQUALS`, `LESS_THAN`, `LESS_THAN_OR_EQUALS`, `CONTAINS`, `DOES_NOT_CONTAIN`, `STARTS_WITH`, `DOES_NOT_START_WITH`, `ENDS_WITH`, `DOES_NOT_END_WITH`, `IS_ONE_OF`, `IS_NOT_ONE_OF`, `HAS_ANY_OF`, `HAS_ALL_OF`, `HAS_NONE_OF`.
- `filter.condition.conditions.conditions.conditions.leftSide` (string): The Field ID to apply the operator on.
- `filter.condition.conditions.conditions.conditions.rightSide` (string | number | boolean | string[]): The value to compare against. Can be a string, number, or an array for operators like IS_ONE_OF.
- `filter.condition.conditions.conditions.conditions.lowerBound` (string): Lower bound for IS_BETWEEN operator.
- `filter.condition.conditions.conditions.conditions.upperBound` (string): Upper bound for IS_BETWEEN operator.
- `filter.condition.conditions.conditions.conditions.conditions` (object[]): Used for AND/OR operators to nest conditions.
- `filter.condition.conditions.conditions.conditions.conditions.operator` (enum) One of: `AND`, `OR`, `IS_EMPTY`, `IS_NOT_EMPTY`, `IS_BETWEEN`, `IS_NOT_BETWEEN`, `IS_WITHIN`, `IS_NOT_WITHIN`, `IS`, `IS_NOT`, `GREATER_THAN`, `GREATER_THAN_OR_EQUALS`, `LESS_THAN`, `LESS_THAN_OR_EQUALS`, `CONTAINS`, `DOES_NOT_CONTAIN`, `STARTS_WITH`, `DOES_NOT_START_WITH`, `ENDS_WITH`, `DOES_NOT_END_WITH`, `IS_ONE_OF`, `IS_NOT_ONE_OF`, `HAS_ANY_OF`, `HAS_ALL_OF`, `HAS_NONE_OF`.
- `filter.condition.conditions.conditions.conditions.conditions.leftSide` (string): The Field ID to apply the operator on.
- `filter.condition.conditions.conditions.conditions.conditions.rightSide` (string | number | boolean | string[]): The value to compare against. Can be a string, number, or an array for operators like IS_ONE_OF.
- `filter.condition.conditions.conditions.conditions.conditions.lowerBound` (string): Lower bound for IS_BETWEEN operator.
- `filter.condition.conditions.conditions.conditions.conditions.upperBound` (string): Upper bound for IS_BETWEEN operator.
- `filter.condition.conditions.conditions.conditions.conditions.conditions` (object[]): Used for AND/OR operators to nest conditions.
- `sorting` (object[])
- `sorting.sortingField` (string): The Field ID to apply the sorting on
- `sorting.sortType` (enum) One of: `ASC`, `DESC`.
- `paging` (object)
- `paging.offset` (integer, default: 0)
- `paging.limit` (integer, default: 10)
## Responses
### 200: A paginated list of matching records.
- `data` (object[])
- `data.id` (string)
- `data.tableId` (string)
- `data.fields` (Record): A map of Field IDs to their values for this record.
- `data.createdAt` (string)
- `data.updatedAt` (string)
- `metadata` (object)
- `metadata.offset` (integer)
- `metadata.limit` (integer)
- `metadata.total` (integer)
```json
{
"data": [
{
"id": "",
"tableId": "",
"fields": {},
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
],
"metadata": {
"offset": 123,
"limit": 123,
"total": 123
}
}
```
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request POST \
--url 'https://tables-api.softr.io/api/v1/databases//tables//records/search' \
--header 'Softr-Api-Key: ' \
--header 'Content-Type: application/json' \
--data '{
"filter": {
"condition": {
"operator": "AND",
"leftSide": "",
"rightSide": "",
"lowerBound": "",
"upperBound": "",
"conditions": [
{}
]
}
},
"sorting": [
{
"sortingField": "",
"sortType": "ASC"
}
],
"paging": {
"offset": 0,
"limit": 10
}
}'
```
---
# Get Single Record
Source: https://docs.softr.io/softr-api/softr-database-api/records/get-single-record
## Endpoint
`GET https://tables-api.softr.io/api/v1/databases/{databaseId}/tables/{tableId}/records/{recordId}`
Retrieve details of a specific record by its ID.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
- `tableId` (string, required)
- `recordId` (string, required)
## Query parameters
- `fieldNames` (boolean, default: false): If true, use field names as keys in the fields object instead of field IDs.
## Responses
### 200: Record details.
- `data` (object)
- `data.id` (string)
- `data.tableId` (string)
- `data.fields` (Record): A map of Field IDs to their values for this record.
- `data.createdAt` (string)
- `data.updatedAt` (string)
```json
{
"data": {
"id": "",
"tableId": "",
"fields": {},
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
}
```
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request GET \
--url 'https://tables-api.softr.io/api/v1/databases//tables//records/' \
--header 'Softr-Api-Key: '
```
---
# Create Record
Source: https://docs.softr.io/softr-api/softr-database-api/records/create-record
## Endpoint
`POST https://tables-api.softr.io/api/v1/databases/{databaseId}/tables/{tableId}/records`
Create a new record in the specified table.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
- `tableId` (string, required)
## Query parameters
- `fieldNames` (boolean, default: false): If true, use field names as keys in the response fields object instead of field IDs.
## Body (application/json)
- `fields` (Record): A map of Field IDs to their values.
## Responses
### 200: The newly created record.
- `data` (object)
- `data.id` (string)
- `data.tableId` (string)
- `data.fields` (Record): A map of Field IDs to their values for this record.
- `data.createdAt` (string)
- `data.updatedAt` (string)
```json
{
"data": {
"id": "",
"tableId": "",
"fields": {},
"createdAt": "2024-01-01T00:00:00Z",
"updatedAt": "2024-01-01T00:00:00Z"
}
}
```
### 429: Rate limit exceeded.
No response body.
## Request example
```bash
curl --request POST \
--url 'https://tables-api.softr.io/api/v1/databases//tables//records' \
--header 'Softr-Api-Key: ' \
--header 'Content-Type: application/json' \
--data '{
"fields": {}
}'
```
---
# Update Record
Source: https://docs.softr.io/softr-api/softr-database-api/records/update-record
## Endpoint
`PATCH https://tables-api.softr.io/api/v1/databases/{databaseId}/tables/{tableId}/records/{recordId}`
Partially update a specific record by its ID. Only the fields provided in the request body will be changed.
## Authorizations
- `Softr-Api-Key` (API key, header, required)
## Path parameters
- `databaseId` (string, required)
- `tableId` (string, required)
- `recordId` (string, required)
## Query parameters
- `fieldNames` (boolean, default: false): If true, use field names as keys in the response fields object instead of field IDs.
## Body (application/json)
- `fields` (Record): A map of Field IDs to their new values.
## Responses
### 200: The updated record.
- `data` (object)
- `data.id` (string)
- `data.tableId` (string)
- `data.fields` (Record): A map of Field IDs to their values for this record.
- `data.createdAt` (string)
- `data.updatedAt` (string
)}