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.

Overview

Pricing

Managed Weaviate uses fixed SKUs with compute and storage included in the monthly price. During the private preview, clusters are not billed.

Storage capacity includes both 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.

Features

Each Managed Weaviate cluster includes:

• Weaviate 1.37.1: Clusters run version 1.37.1. DigitalOcean upgrades the engine on a managed cadence, and new clusters are always provisioned on the latest supported version.
• Open-source Weaviate API: REST, GraphQL, and gRPC endpoints. Official clients for Python, JavaScript/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 using the hybrid search API.
• Automatic backups: Daily backups with a 7-day retention period.
• TLS by default: All connections are secured over HTTPS (port 443) for both HTTP and gRPC.

During private preview, you create and manage clusters with the DigitalOcean API. The full workflow for provisioning, configuration, backups, and teardown is documented below.

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.

Feedback and Support

Managed Weaviate is in private preview. APIs, SKUs, regions, and Control Panel elements may change before general availability. Private preview releases may not be suitable for production workloads. We recommend avoiding sensitive workloads in preview features.

To request access or give feedback during the private preview, contact your Customer Success Manager or Solutions Architect.

Our terms of service govern your use of DigitalOcean and cover details of eligibility, content, use, payments and billing, and warranties.

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

DigitalOcean offers three vector database engines.

• Weaviate: When you are building retrieval-augmented generation (RAG), semantic search, or recommendations and want a purpose-built vector database with native hybrid search.
• 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.
• PostgreSQL with pgvector: When your vectors live alongside relational data and you want to query them in SQL.

Prerequisites

You need:

• DigitalOcean account: Opted into the Managed Weaviate private preview.
• DigitalOcean API token: With write scope. See How to create a personal access token.
• Project UUID: The UUID of the project that will own the cluster.
• 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.

How to 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.

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": 1,
      "disk_mib": 3072,
      "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.

How to 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.

How to Back Up and Restore a Cluster

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"

How to 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.

Limitations and Known Issues

The following limits apply during the private preview:

• Access: Opt-in and limited to approved accounts.
• Billing and support: Clusters are not billed and are not covered by a paid support SLA.
• SKU pricing, regional availability, and SLAs: May change before general availability.
• Production use: Preview clusters are not recommended for production workloads.
• Control Panel: Does not yet include Managed Weaviate support. All cluster management goes through the DigitalOcean API.