Get to know our frameworks

Select an app template built on your preferred framework.

Build apps on our native app editor. Use drag and drop elements, Velo code and Wix APIs to develop custom features.

Streamline your app development process with the Wix CLI. Get a familiar developer experience with minimal setup and configuration.

Take full control over your app's tech stack, deployment, and hosting.

App templates

Wix Blocks templates

Wix CLI templates

Self-hosted templates

Kickstart your app development with templates built on your preferred Wix developer tool. Browse templates for practical foundation and get to know the Wix ecosystem.

Wix App Templates for Developers

This example apps can be used as a starting point for building your own app, for concrete examples of how to use Wix framework, or for inspiration.

Choose a template.<0 />Build an app.

Browse by:

How to build it step by step:

This template is built with:

Read how this template was built, step by step.

How we built this template

Deployment instructions:

Choose a package manager and run the command in your terminal.

Copy command

Before you get started, make sure you have the following:

Prerequisite steps

Get started with Wix CLI

Begin by setting up your Next.js project with your preferred hosting platform.

Select your hosting service

Start the deployment flow and set up your template repo on Netlify. After you finish set up, come back here and add your Netlify custom domain.

Copy the code from our Git repo to deploy your app on any platform that supports Next.js.

Start the deployment flow and set up your template repo on Vercel. After you finish set up, come back here and add your Vercel generated URL.

Add the base URL and give your app a name.

App details

Go to the app dashboard and test your app to ensure a smooth integration within the Wix ecosystem. <0>Learn more about app checks and testing</0>

Define your environment

Terminal

Related templates

Note

Warning

Your app name will be used as the namespace suffix.

Name your app to generate a namespace. This lets you refer to your app in code later on.

Go Headless

Build Apps

Client

API Preview

Ricos

Develop Websites

REST

Velo

GraphQL (Alpha)

externalDatabaseConnection

ExternalDatabaseConnection

Options for creating an external database connection.

options

CreateExternalDatabaseConnectionOptions

Creates a new external database connection.

The `externalDatabaseConnection` parameter must include a `name`, `endpoint`, and `configuration` details for the external database.
If any of these are missing, the external database connection isn't created.

import { externalDatabaseConnections } from '@wix/data';

async function createExternalDatabaseConnection(externalDatabaseConnection, options) {
  const response = await externalDatabaseConnections.createExternalDatabaseConnection(externalDatabaseConnection, options);
};

createExternalDatabaseConnection: Wix-hosted

import { createClient } from '@wix/sdk';
import { externalDatabaseConnections } from '@wix/data';
// Import the auth strategy for the relevant access type
// Import the relevant host module if needed

const myWixClient = createClient ({
  modules: { externalDatabaseConnections },
  // Include the auth strategy and host as relevant
});


async function createExternalDatabaseConnection(externalDatabaseConnection, options) {
  const response = await myWixClient.externalDatabaseConnections.createExternalDatabaseConnection(externalDatabaseConnection, options);
};

Self-hosted SDK calls require you to [create a client](https://www.sbdautomotive.com/ja/wg-cgi/dev.wix.com/docs/sdk/articles/work-with-the-sdk/about-the-wix-client).

createExternalDatabaseConnection: Self-hosted

createExternalDatabaseConnection

Manage External Database Connections

Details of external database connection created.

Name of the external database connection to delete.

name

string

Deletes an external database connection.

> **Note:** Once an external database connection is deleted, it can't be restored. To reconnect the database you need to create a new external database connection.

import { externalDatabaseConnections } from '@wix/data';

async function deleteExternalDatabaseConnection(name) {
  const response = await externalDatabaseConnections.deleteExternalDatabaseConnection(name);
};

deleteExternalDatabaseConnection: Wix-hosted

import { createClient } from '@wix/sdk';
import { externalDatabaseConnections } from '@wix/data';
// Import the auth strategy for the relevant access type
// Import the relevant host module if needed

const myWixClient = createClient ({
  modules: { externalDatabaseConnections },
  // Include the auth strategy and host as relevant
});


async function deleteExternalDatabaseConnection(name) {
  const response = await myWixClient.externalDatabaseConnections.deleteExternalDatabaseConnection(name);
};

deleteExternalDatabaseConnection: Self-hosted

deleteExternalDatabaseConnection

void

Name of the external database connection to retrieve.

Retrieves an external database connection by name.

import { externalDatabaseConnections } from '@wix/data';

async function getExternalDatabaseConnection(name) {
  const response = await externalDatabaseConnections.getExternalDatabaseConnection(name);
};

getExternalDatabaseConnection: Wix-hosted

import { createClient } from '@wix/sdk';
import { externalDatabaseConnections } from '@wix/data';
// Import the auth strategy for the relevant access type
// Import the relevant host module if needed

const myWixClient = createClient ({
  modules: { externalDatabaseConnections },
  // Include the auth strategy and host as relevant
});


async function getExternalDatabaseConnection(name) {
  const response = await myWixClient.externalDatabaseConnections.getExternalDatabaseConnection(name);
};

getExternalDatabaseConnection: Self-hosted

getExternalDatabaseConnection

Details of the external database connection requested.

ListExternalDatabaseConnectionsOptions

Retrieves a list of all external database collections associated with the site or project.

import { externalDatabaseConnections } from '@wix/data';

async function listExternalDatabaseConnections(options) {
  const response = await externalDatabaseConnections.listExternalDatabaseConnections(options);
};

listExternalDatabaseConnections: Wix-hosted

import { createClient } from '@wix/sdk';
import { externalDatabaseConnections } from '@wix/data';
// Import the auth strategy for the relevant access type
// Import the relevant host module if needed

const myWixClient = createClient ({
  modules: { externalDatabaseConnections },
  // Include the auth strategy and host as relevant
});


async function listExternalDatabaseConnections(options) {
  const response = await myWixClient.externalDatabaseConnections.listExternalDatabaseConnections(options);
};

listExternalDatabaseConnections: Self-hosted

listExternalDatabaseConnections

ListExternalDatabaseConnectionsResponse

Name of the external database connection.
An external database connection may connect to one or more external data collections or tables.
These are represented as `connectionName/dataCollectionId`.

Updated external database connection details. The existing connection is replaced with this version.

UpdateExternalDatabaseConnection

Updates an external database connection.

An external database collection name must be provided in `name`.
If an existing external database connection is found with the same name, that connection's details are updated.
If no external database connection has that name, the request fails.

> **Note:** After an external database connection is updated, it only contains the values provided in the request. All previous values are lost.

import { externalDatabaseConnections } from '@wix/data';

async function updateExternalDatabaseConnection(name, externalDatabaseConnection) {
  const response = await externalDatabaseConnections.updateExternalDatabaseConnection(name, externalDatabaseConnection);
};

updateExternalDatabaseConnection: Wix-hosted

import { createClient } from '@wix/sdk';
import { externalDatabaseConnections } from '@wix/data';
// Import the auth strategy for the relevant access type
// Import the relevant host module if needed

const myWixClient = createClient ({
  modules: { externalDatabaseConnections },
  // Include the auth strategy and host as relevant
});


async function updateExternalDatabaseConnection(name, externalDatabaseConnection) {
  const response = await myWixClient.externalDatabaseConnections.updateExternalDatabaseConnection(name, externalDatabaseConnection);
};

updateExternalDatabaseConnection: Self-hosted

updateExternalDatabaseConnection

Updated external database connection details.

---
title: Introduction
---

# About the External Database Connections API

The External Database Connections API enables you to connect an external database to a Wix project or site.

## Internal vs. external databases

Wix provides a comprehensive platform with integrated database capabilities. You can use the [Data Collections API](https://www.sbdautomotive.com/ja/wg-cgi/dev.wix.com/api/sdk/data/collections) to create, modify, and delete data collections in a Wix project or site, and you can use the [Data Items API](https://www.sbdautomotive.com/ja/wg-cgi/dev.wix.com/api/sdk/data/items) to access and manage data within those collections.

Wix's database capabilities cover a wide range of use cases for apps that need to store data. However, certain projects have very specific requirements that make it necessary to use an external database. For example, you may need to access existing data that is already stored on an external service, or you may need your data to be stored in a relational database.

Once the connection between an external database and a Wix project or site is established, you can access the collection using Wix Data APIs, including the [Data Items API](https://www.sbdautomotive.com/ja/wg-cgi/dev.wix.com/api/sdk/data/items), in the same way you would with a native collection. You can also access the collection through the Content Management System(CMS).

For more information on connecting external databases with a Wix site, see [Integrating External Databases with Your Wix Site](https://support.wix.com/en/article/velo-integrating-external-databases-with-your-wix-site).

## Preparing an external database

Before the External Database Connections API can connect a Wix project or site with an external database, you need to prepare the external database by creating an [external database adaptor](https://support.wix.com/en/article/velo-integrating-external-databases-with-your-wix-site#what-is-an-external-database-adaptor).

An external database adaptor is a server that translates Wix data requests from a Wix project or site into an external database's protocol, and translates the response back into a format that Wix APIs can read. This enables Wix APIs, projects, and sites to treat the external database exactly as if it was an internal data collection.

If your database is hosted on one of the major cloud platforms, you can consult one of our tutorials for instructions on how to [deploy an external database adaptor](https://support.wix.com/en/article/velo-integrating-external-databases-with-your-wix-site#deploy-an-external-database-adaptor).

Otherwise, for details on the required specifications for an external database adaptor, see the [External Database Collections SPI](https://www.wix.com/velo/reference/spis/external-database-collections).

## Ensuring read-write access

If you want to enable read-write access to your external database using the [Data Items API](https://www.sbdautomotive.com/ja/wg-cgi/dev.wix.com/api/sdk/data/items), ensure your external database's table or schema includes the following fields:
* `_id`
* `_createdDate`
* `_updatedDate`
* `_owner`
If these fields are absent, access to the external database is read-only. You may prefer this option for data that your app only needs to retrieve and doesn't need to manage.

## Supported databases

The External Database Connections API works with several kinds of databases. For a full list, see [Supported Databases](https://support.wix.com/en/article/velo-integrating-external-databases-with-your-wix-site#supported-databases).


To use the ExternalDatabaseConnections API, install the `@wix/data` package using npm or Yarn:
  ```console
npm install @wix/data
```

or

```console
yarn add @wix/data
```

Then import `{ externalDatabaseConnections }` from `@wix/data`:

```js
import { externalDatabaseConnections } from '@wix/data'
```
  

data_external-database-connections

Capabilities

Whether the external database supports creating new collections, updating the structure of existing collections, or deleting them.

collectionModificationsSupported

boolean

Field types the external database supports.
This field only applies when `collectionModificationsSupported` is `true`.

fieldTypes

CauseOfFailure

CollectionsFound

ConnectionStatus

If and why a connection attempt failed.
+ `NONE`: No connection failure.
+ `COMMUNICATION_FAILURE`: General communication failure.
+ `DESTINATION_HOST_UNREACHABLE`: External database host is unreachable.
+ `UNAUTHORIZED`: Unauthorized to access external database.
+ `DESTINATION_ENDPOINT_NOT_DEFINED`: `Endpoint` property is not set.

causeOfFailure

Whether the external database has existing collections. Possible values are:
+ `UNKNOWN`: The attempt to connect to the external database failed, so status is unknown.
+ `NO`: External database does not have any existing collections.
+ `YES`: External database has existing collections.

hasCollections

Whether the connection was established successfully.

successful

ConnectionType

connectionType

EventMetadata

Unique event ID.
Allows clients to ignore duplicate webhooks.

A sequence number defining the order of updates to the underlying entity.
For example, given that some entity was updated at 16:00 and than again at 16:01,
it is guaranteed that the sequence number of the second update is strictly higher than the first.
As the consumer, you can use this value to ensure that you handle messages in the correct order.
To do so, you will need to persist this number on your end, and compare the sequence number from the
message against the one you have stored. Given that the stored number is higher, you should ignore the message.

entityEventSequence

Assumes actions are also always typed to an entity_type
Example: wix.stores.catalog.product, wix.bookings.session, wix.payments.transaction

entityFqdn

ID of the entity associated with the event.

entityId

Event timestamp in [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) format and UTC time. For example: 2020-04-26T13:57:50.699Z

eventTime

eventType

The identification type and identity data.

identity

IdentificationData

instanceId

If present, indicates the action that triggered the event.

originatedFrom

This is top level to ease client code dispatching of messages (switch on entity_fqdn+slug)
This is although the created/updated/deleted notion is duplication of the oneof types
Example: created/updated/deleted/started/completed/email_opened

slug

Whether the event was triggered as a result of a privacy regulation application
(for example, GDPR).

triggeredByAnonymizeRequest

capabilities

Settings passed to the external database connection as part of each request.
These settings can relate to authentication, tenancy, or provide any other information needed for processing a request.
Their content and structure depend on the specific requirements of the external database's API.

configuration

Status of the external database connection. Includes whether the connection was established successfully, and if not, the reason for the failure.

connectionStatus

Base URL for provisioning and managing data in the external database. For example: `https://example.com/my-external-database`.

endpoint

ExternalDatabaseConnectionCreatedEnvelope

entity

metadata

ExternalDatabaseConnectionDeletedEnvelope

ExternalDatabaseConnectionUpdatedEnvelope

FieldType

ID of a site visitor that has not logged in to the site.

anonymousVisitorId

appId

ID of a site visitor that has logged in to the site.

memberId

ID of a Wix user (site owner, contributor, etc.).

wixUserId

identityType

WebhookIdentityType

paging

Paging

externalDatabaseConnections

pagingMetadata

PagingMetadata

OnExternalDatabaseConnectionCreatedHandler

event

OnExternalDatabaseConnectionDeletedHandler

OnExternalDatabaseConnectionUpdatedHandler

limit

number

Number of items to skip in the current sort order.

offset

Number of items returned in the response.

count

Flag that indicates the server failed to calculate the `total` field.

tooManyToCount

Total number of items that match the query.

total

handler

Triggered when an external database connection is created.

import { externalDatabaseConnections } from '@wix/data';

externalDatabaseConnections.onExternalDatabaseConnectionCreated((event) => {
    // handle your event here
});

onExternalDatabaseConnectionCreated: Wix-hosted

import { createClient, AppStrategy } from '@wix/sdk';
import { externalDatabaseConnections } from '@wix/data';

const wixClient = createClient({
  auth: AppStrategy({
    appId: 'MY-APP-ID',
    publicKey: 'YOUR_APP_PUBLIC_KEY',
   }),
   modules: {
      externalDatabaseConnections,
    },
});

wixClient.externalDatabaseConnections.onExternalDatabaseConnectionCreated((event) => {
    // handle your event here
});

onExternalDatabaseConnectionCreated: Self-hosted

onExternalDatabaseConnectionCreated

Triggered when an external database connection is deleted.

import { externalDatabaseConnections } from '@wix/data';

externalDatabaseConnections.onExternalDatabaseConnectionDeleted((event) => {
    // handle your event here
});

onExternalDatabaseConnectionDeleted: Wix-hosted

import { createClient, AppStrategy } from '@wix/sdk';
import { externalDatabaseConnections } from '@wix/data';

const wixClient = createClient({
  auth: AppStrategy({
    appId: 'MY-APP-ID',
    publicKey: 'YOUR_APP_PUBLIC_KEY',
   }),
   modules: {
      externalDatabaseConnections,
    },
});

wixClient.externalDatabaseConnections.onExternalDatabaseConnectionDeleted((event) => {
    // handle your event here
});

onExternalDatabaseConnectionDeleted: Self-hosted

onExternalDatabaseConnectionDeleted

Triggered when an external database connection is updated.

import { externalDatabaseConnections } from '@wix/data';

externalDatabaseConnections.onExternalDatabaseConnectionUpdated((event) => {
    // handle your event here
});

onExternalDatabaseConnectionUpdated: Wix-hosted

import { createClient, AppStrategy } from '@wix/sdk';
import { externalDatabaseConnections } from '@wix/data';

const wixClient = createClient({
  auth: AppStrategy({
    appId: 'MY-APP-ID',
    publicKey: 'YOUR_APP_PUBLIC_KEY',
   }),
   modules: {
      externalDatabaseConnections,
    },
});

wixClient.externalDatabaseConnections.onExternalDatabaseConnectionUpdated((event) => {
    // handle your event here
});

deleteExternalDatabaseConnection( )