For AI agents: The documentation index is at https://docs.digitalocean.com/llms.txt. Markdown versions of pages use the same URL with index.html.md in place of the HTML page (for example, append index.html.md to the directory path instead of opening the HTML document).

DigitalOcean Managed Weaviate is a fully managed offering of the Weaviate open-source vector database. Clusters are provisioned, secured, backed up, and patched by DigitalOcean. You are responsible for your data, your schema, and the application that reads and writes to the cluster.

During private preview, you create and manage clusters with the DigitalOcean API. The Control Panel surface is not yet enabled. The full provisioning, configuration, backup, and tear-down workflow is documented below.

What You Get with Managed Weaviate

Each Managed Weaviate cluster includes:

• Weaviate 1.37.1: Clusters run Weaviate 1.37.1. DigitalOcean upgrades the cluster engine on a managed cadence; new clusters always provision on the current supported version.
• Open-source Weaviate API: REST, GraphQL, and gRPC endpoints. The official Weaviate clients for Python, JavaScript and TypeScript, Go, and Java work without modification. See the client libraries overview.
• Hybrid search: Combine vector similarity and BM25 keyword relevance in a single query with the hybrid search API.
• Automatic backups: DigitalOcean runs daily backups automatically and retains them for 7 days.
• TLS on every connection: Clusters are reachable over the public internet on port 443 for both HTTP and gRPC.

Cluster Plans

Managed Weaviate uses fixed SKU pricing. Compute and storage are included in the monthly price.

Storage is sized to match the SKU and includes vectors and inverted indexes.

All plans are highly available.

Resize is upgrade-only: small to medium or large, and medium to large. Downsizing is not supported.

You can review live plan details, including current pricing and enabled regions, by calling the List plans endpoint.

For measured throughput and latency on each tier, see Weaviate benchmarks.

Availability

During private preview, Managed Weaviate clusters can only be created in TOR1 (Toronto, Canada). Additional regions will be enabled before general availability. The enabled_regions field returned by the List plans endpoint is the source of truth for region availability.

How to Decide: Weaviate, OpenSearch, or PostgreSQL with pgvector

DigitalOcean offers three vector database engines under DigitalOcean Vector Databases.

• Choose Weaviate when you are building retrieval-augmented generation (RAG), semantic search, or recommendations and want a purpose-built vector database with native hybrid search.
• Choose OpenSearch when you already rely on OpenSearch for full-text or log search. The embedding call happens in your application code, so any embedding provider works, including DigitalOcean Serverless Inference, a third-party API, or a self-hosted model.
• Choose PostgreSQL with pgvector when your vectors live alongside relational data and you want to query them in SQL.

Provision and Connect to a Cluster

The sections below walk through the cluster lifecycle using the DigitalOcean API. All requests are made against https://api.digitalocean.com/v2/vector-databases and authenticated with a DigitalOcean API token sent in the Authorization header.

Prerequisites

You need:

• A DigitalOcean account opted into the Managed Weaviate private preview.
• A DigitalOcean API token with write scope. See How to create a personal access token.
• The UUID of the project that will own the cluster.
• An HTTP client. The examples use curl.

Set environment variables for the token and project ID before running the examples:

export DIGITALOCEAN_TOKEN="<your-do-api-token>"
export PROJECT_ID="<your-project-uuid>"

Do not commit either value to source control. Treat the API token like a password.

Step 1: List Available Plans

Call the plans endpoint to confirm sizing options and the regions enabled for your account.

curl -X GET "https://api.digitalocean.com/v2/vector-databases/plans" \
  -H "Authorization: Bearer $DIGITALOCEAN_TOKEN" \
  -H "Content-Type: application/json"

The response lists each plan along with its vcpu, usable_memory_mib, disk_mib, pricing, and enabled_regions array.

{
  "plans": [
    {
      "size": "small",
      "vcpu": 2,
      "disk_mib": 3000,
      "usable_memory_mib": 2048,
      "deprecated": false,
      "enabled_regions": ["tor1"]
    }
  ]
}

Step 2: Create a Cluster

Send a POST request with the cluster name, region, plan size, and project ID.

curl -X POST "https://api.digitalocean.com/v2/vector-databases" \
  -H "Authorization: Bearer $DIGITALOCEAN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-vector-db",
    "region": "tor1",
    "size": "small",
    "project_id": "'"$PROJECT_ID"'",
    "tags": ["production", "ml-team"]
  }'

A successful response returns the cluster object with status: "pending" and a null endpoints field. Provisioning typically completes in about 5 minutes.

{
  "vector_db": {
    "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "name": "my-vector-db",
    "region": "tor1",
    "status": "pending",
    "size": "small",
    "config": {
      "default_quantization": "rq",
      "enable_auto_schema": true
    },
    "endpoints": null,
    "tags": ["production", "ml-team"]
  }
}

The status field moves through this lifecycle:

Step 3: Wait for the Cluster to Become Active

Poll the cluster until status is active and endpoints contains the HTTP and gRPC hosts.

curl -X GET "https://api.digitalocean.com/v2/vector-databases/$CLUSTER_ID" \
  -H "Authorization: Bearer $DIGITALOCEAN_TOKEN"

{
  "vector_db": {
    "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "status": "active",
    "endpoints": {
      "http": "https://my-vector-db-abc123.weaviate.digitalocean.com",
      "grpc": "my-vector-db-abc123-grpc.weaviate.digitalocean.com:443"
    }
  }
}

Always read the hostname from the endpoints object instead of constructing it. Hostnames are not stable across cluster recreation.

Step 4: Retrieve the Weaviate API Token

Fetch the credentials the Weaviate client uses to authenticate. This is a separate token from your DigitalOcean API token.

curl -X GET "https://api.digitalocean.com/v2/vector-databases/$CLUSTER_ID/credentials" \
  -H "Authorization: Bearer $DIGITALOCEAN_TOKEN"

{
  "user_id": "admin",
  "api_token": "<weaviate-api-token>"
}

Store the api_token in a secret manager. The Weaviate client sends it as a Bearer token on every request.

Step 5: Connect with the Weaviate Client

Both the HTTP and gRPC endpoints listen on port 443 with TLS. Pass the values from endpoints and the api_token from step 4 to your client.

Python (weaviate-client v4)

import weaviate
from weaviate.auth import AuthApiKey

client = weaviate.connect_to_custom(
    http_host="my-vector-db-abc123.weaviate.digitalocean.com",
    http_port=443,
    http_secure=True,
    grpc_host="my-vector-db-abc123-grpc.weaviate.digitalocean.com",
    grpc_port=443,
    grpc_secure=True,
    auth_credentials=AuthApiKey("<weaviate-api-token>"),
)

print(client.is_ready())

Install the client with pip install -U "weaviate-client>=4.10.0".

JavaScript or TypeScript (weaviate-client)

import weaviate from 'weaviate-client';

const client = await weaviate.connectToCustom({
    httpHost: 'my-vector-db-abc123.weaviate.digitalocean.com',
    httpPort: 443,
    httpSecure: true,
    grpcHost: 'my-vector-db-abc123-grpc.weaviate.digitalocean.com',
    grpcPort: 443,
    grpcSecure: true,
    authCredentials: new weaviate.ApiKey('<weaviate-api-token>'),
});

console.log(await client.isReady());

Install the client with npm install weaviate-client.

curl (health check)

curl -X GET "https://my-vector-db-abc123.weaviate.digitalocean.com/v1/.well-known/ready" \
  -H "Authorization: Bearer <weaviate-api-token>"

A 200 OK response confirms the cluster is reachable and ready for queries.

Manage a Cluster

List All Clusters

curl -X GET "https://api.digitalocean.com/v2/vector-databases?page=1&per_page=20" \
  -H "Authorization: Bearer $DIGITALOCEAN_TOKEN"

Use page and per_page for pagination.

Update Cluster Configuration

Update auto-schema or default quantization with a PUT request:

curl -X PUT "https://api.digitalocean.com/v2/vector-databases/$CLUSTER_ID" \
  -H "Authorization: Bearer $DIGITALOCEAN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "config": {
      "enable_auto_schema": false,
      "default_quantization": "pq"
    }
  }'

The four quantization options are:

• rq (Rotational Quantization, default): Balanced compression and recall.
• pq (Product Quantization): Higher compression with a small accuracy tradeoff.
• bq (Binary Quantization): Maximum compression and fastest search.
• sq (Scalar Quantization): Simple, fast encoding for moderate compression.

Existing collections keep their current settings. The new default applies only to collections created after the update.

Update Tags

Replace the full tag set with a PUT request:

curl -X PUT "https://api.digitalocean.com/v2/vector-databases/$CLUSTER_ID/tags" \
  -H "Authorization: Bearer $DIGITALOCEAN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "tags": ["production", "v2", "critical"] }'

Resize a Cluster

Resize is upgrade-only. Allowed paths: small to medium or large, and medium to large.

curl -X POST "https://api.digitalocean.com/v2/vector-databases/$CLUSTER_ID/resize" \
  -H "Authorization: Bearer $DIGITALOCEAN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "size": "medium" }'

The cluster status moves out of active while the resize runs and returns to active when it completes. Connections may be briefly interrupted during the cutover.

Backups and Restore

DigitalOcean runs daily backups automatically and retains them for 7 days. Backups cannot be created on demand during private preview.

List Backups

curl -X GET "https://api.digitalocean.com/v2/vector-databases/$CLUSTER_ID/backups" \
  -H "Authorization: Bearer $DIGITALOCEAN_TOKEN"

{
  "backups": [
    {
      "backup_id": "vectordb-abc123-20260115-120000",
      "status": "SUCCESS",
      "started_at": "2026-01-15T12:00:00Z",
      "completed_at": "2026-01-15T12:05:00Z"
    }
  ]
}

Restore from a Backup

Restoring overwrites the cluster’s current state with the contents of the named backup.

curl -X POST "https://api.digitalocean.com/v2/vector-databases/$CLUSTER_ID/backups/$BACKUP_ID/restore" \
  -H "Authorization: Bearer $DIGITALOCEAN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{}'

Restores are asynchronous. Poll the restore endpoint until status is SUCCESS or FAILED:

curl -X GET "https://api.digitalocean.com/v2/vector-databases/$CLUSTER_ID/backups/$BACKUP_ID/restore" \
  -H "Authorization: Bearer $DIGITALOCEAN_TOKEN"

Delete a Cluster

Deletion is irreversible. All data, including backups, is destroyed.

curl -X DELETE "https://api.digitalocean.com/v2/vector-databases/$CLUSTER_ID" \
  -H "Authorization: Bearer $DIGITALOCEAN_TOKEN"

A 200 OK response with an empty body indicates the cluster was queued for deletion.

Error Reference

Common error bodies:

{
  "error": "name must be 3-30 characters, start with a letter, and contain only lowercase letters, numbers, and hyphens"
}

{
  "error": "region 'xyz1' is not available for vector databases"
}

{
  "error": "cannot resize from 'large' to 'small'; only upgrades are supported"
}

Best Practices

• Start small: Begin on the small plan, validate your workload, and resize up when you have measured demand.
• Read endpoints from the API: Hostnames returned in the endpoints object are the source of truth. Do not construct them by hand.
• Use gRPC for batch ingest: The gRPC endpoint sustains higher throughput than HTTP for bulk inserts and large queries.
• Tag every cluster: Tags surface in billing and the project view, which makes ownership clear when you operate more than one cluster.
• Store credentials in a secret manager: Both the DigitalOcean API token and the Weaviate api_token are sensitive.
• Match region to your application: Choose the region closest to the application that calls Weaviate to minimize round-trip latency.

Private Preview Limits

Weaviate is in private preview. The following limits apply during the preview:

• Access is opt-in and limited to approved accounts.
• Clusters are not billed and are not covered by a paid support SLA.
• SKU pricing, regional availability, and SLAs may change before general availability.
• Preview clusters are not recommended for production workloads.
• The Control Panel does not yet have Managed Weaviate support. All cluster management goes through the DigitalOcean API.