Weaviate

Tested with: Weaviate 1.39 on Databasezy · zb CLI 0.1

Weaviate is an open-source vector database. It stores objects together with their vectors in typed collections and combines vector, keyword (BM25) and hybrid search in one query.

Overview

Each instance runs the open-source Weaviate server as a single node with API-key authentication; anonymous access is turned off. It serves REST and GraphQL on the instance host and gRPC on a second -grpc hostname, both on port 443 behind TLS. No vectorizer or generative modules are enabled, so you bring your own vectors: send embeddings with your objects and with your queries.

Weaviate at a glance, from the engine catalogue
Status	Available
Category	Vector
Versions	1.39, 1.38 (newest is the default)
Protocol and port	HTTPS on `443`; also grpc on 443 (host weaviate-7f3k-grpc.us-east.databasezy.com)
Runtime	Single-node engine (semitechnologies/weaviate)
Backups	weaviate_export
Point-in-time recovery	No
Pause	Scale to zero
Free plan	No, paid plans only
Licence	BSD-3-Clause

When to use it

Hybrid search that blends BM25 keyword scores with vector similarity.
Retrieval for LLM applications where objects carry many properties you filter on.
Multi-tenant applications that keep each tenant’s data in its own tenant shard of a collection.

Pick Qdrant for a lighter vector store with payload filters, and Meilisearch for typo-tolerant keyword search.

Create an instance

Open the portal and choose New instance.
Pick Weaviate and a version (1.39, 1.38).
Choose a size and region. Secure placement is listed only after your organization has signed the BAA.
Check the hourly price and monthly estimate, then confirm. The Connect tab fills in when the instance is ready.

zb instances create --engine weaviate --engine-version 1.39 \
  --size s1 --region us-east --name weaviate-demo --wait

# Reveal the credentials once and store them in your secret manager
zb instances credentials reveal weaviate-demo

curl -sS https://api.databasezy.com/v1/orgs/$ZB_ORG/projects/$ZB_PROJECT/instances \
  -H "Authorization: Bearer $ZB_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "engine": "weaviate",
  "engine_version": "1.39",
  "size": "s1",
  "region": "us-east",
  "name": "weaviate-demo"
}'

The response is 201 with the instance in status requested, or 202 when a team approval policy applies. See the REST API reference.

Connect

Endpoint and credentials

How a Weaviate instance is reached: host, ports, TLS and credentials
Host	`weaviate-<id>.<region>.databasezy.com`, for example `weaviate-7f3k.us-east.databasezy.com`
Port `443`	REST and GraphQL API
Port `443`	gRPC API over HTTP/2, required by the v4 Python and v3 TypeScript clients , on host `weaviate-7f3k-grpc.us-east.databasezy.com`
Single-IP regions	Single-IP regions use `8443` for HTTP engines instead of `443`. The portal Connect page always shows the right port.
TLS	Required on every port; plaintext is refused. Verify the server: https:// (or the driver's TLS flag) with normal certificate verification; the certificate is publicly trusted.
Credentials	One generated API key (token) with no username, presented as Authorization: Bearer <api-key> on REST and gRPC. Shown once at creation; reveal or rotate it from the Connect tab.

The Python v4 client and the TypeScript v3 client need both endpoints: REST for schema and management calls, gRPC for queries and batch imports. Pass the API key as the client’s API-key credential; plain HTTP calls send Authorization: Bearer <key>.

Drivers and clients

Weaviate listens on port 443 (REST and GraphQL API); port 443 on weaviate-7f3k-grpc.us-east.databasezy.com (gRPC API over HTTP/2, required by the v4 Python and v3 TypeScript clients). Versions: 1.39, 1.38. Replace the example host with the one on your instance's Connect tab; credentials are shown once at creation.

https://weaviate-7f3k.us-east.databasezy.com:443

import os
import weaviate
from weaviate.classes.init import Auth

# The v4 client needs both the REST endpoint and the gRPC endpoint (its own hostname).
client = weaviate.connect_to_custom(
    http_host="weaviate-7f3k.us-east.databasezy.com", http_port=443, http_secure=True,
    grpc_host="weaviate-7f3k-grpc.us-east.databasezy.com", grpc_port=443, grpc_secure=True,
    auth_credentials=Auth.api_key(os.environ["ZB_TOKEN"]),
)
try:
    print(client.is_ready())
    articles = client.collections.get("Article")
    res = articles.query.near_vector(near_vector=[0.12, -0.08, 0.33], limit=3)
    for o in res.objects:
        print(o.properties)
finally:
    client.close()

Tested with: Weaviate 1.39 · weaviate-client 4.x

import weaviate from "weaviate-client";

const client = await weaviate.connectToCustom({
  httpHost: "weaviate-7f3k.us-east.databasezy.com",
  httpPort: 443,
  httpSecure: true,
  grpcHost: "weaviate-7f3k-grpc.us-east.databasezy.com",
  grpcPort: 443,
  grpcSecure: true,
  authCredentials: new weaviate.ApiKey(process.env.ZB_TOKEN ?? ""),
});

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

Tested with: Weaviate 1.39 · weaviate-client 3.x (TypeScript)

curl -sS https://weaviate-7f3k.us-east.databasezy.com:443/v1/meta -H "Authorization: Bearer $ZB_TOKEN"
curl -sS https://weaviate-7f3k.us-east.databasezy.com:443/v1/schema -H "Authorization: Bearer $ZB_TOKEN"

Tested with: Weaviate 1.39 · curl 8

Older clients (Python v3, TypeScript v2) use only REST and GraphQL; they work but miss the gRPC speed-up and are no longer developed upstream.

See Connecting to Databasezy for the CA bundle, the IP allow-list and credential rotation, which work the same for every engine.

Migrate in

Where you can migrate a Weaviate database from, how, and whether continuous sync is available
Source	How	Continuous sync	Guide status
Self-hosted server	Connection string, Local tools (zb migrate --from local)	No	Available
Another Databasezy instance	Instance to instance	No	Coming soon · phase 2

You can migrate from Weaviate Cloud, from a self-hosted Weaviate reachable by URL, or from another Databasezy Weaviate instance. The migration copies the schema first (collections, then cross-references, then tenants), then every object with its stored vectors through Weaviate’s cursor API into batch imports, so nothing is re-vectorised, and compares the object count per collection and tenant. A collection whose vectorizer module is not enabled here (none is) is created with vectorizer none; only active tenants can be read, inactive ones are created empty. It is a one-time copy.

To copy a collection yourself instead, read it out of the source with the client’s iterator (including vectors) and batch-import it into the new instance:

src_coll = source.collections.get("Article")
dst_coll = target.collections.get("Article")  # create it with the same properties first
with dst_coll.batch.dynamic() as batch:
    for obj in src_coll.iterator(include_vector=True):
        batch.add_object(properties=obj.properties, vector=obj.vector["default"], uuid=obj.uuid)

How migrations work explains preflight, verification and cutover, and engine conversions covers moves between compatible engines.

Backups and restore

A backup is a logical export taken through Weaviate’s API while it runs: the schema, the tenants and every object with its vectors, written to object storage. Each object is read whole, but the export is not a point-in-time snapshot: writes made while it runs may or may not be included. Inactive (offloaded) tenants cannot be read and are skipped. A restore creates a new instance and imports the export into it while it runs, collections first, then objects; vectors are restored as stored, nothing is re-vectorised.

Weaviate backups use weaviate_export. They run inside the instance's namespace, stream straight to the cell's object storage and are checksummed on upload. How often they run and how long they are kept follows your plan's backup policy. A backup is always taken before a resize or a version upgrade.

Point-in-time recovery is not available for Weaviate. A restore returns the data as of a scheduled or manual backup. Restores create a new instance by default and leave the original untouched; an in-place restore asks you to type the instance name and takes a pre-change backup first.

zb backups create weaviate-demo --label before-release      # manual snapshot
zb backups list weaviate-demo
zb backups restore weaviate-demo <backup-id> --name weaviate-demo-restore

Pause and scale to zero

Weaviate can scale to zero. A paused instance has no running pods and bills no compute; its storage and backups are kept and billed as usual. Connections are refused until you resume it.

zb instances pause weaviate-demo
zb instances resume weaviate-demo

See Pause and resume for schedules, wake times and billing while paused.

Limits, versions and lifecycle

Versions and lifecycle

Supported versions: 1.39 , 1.38 . New instances default to 1.39; pick another at creation with --engine-version or in the portal.
Minor and patch releases are applied for you in the maintenance window, always after a pre-change backup.
New majors are added within 60 days of the upstream release. A major reaches end of life on Databasezy six months after upstream ends support, with notices 90, 30 and 7 days ahead.
Moving between majors is a new instance plus an instance-to-instance migration, so you can test the new version before cutting over.

Sizes and limits

Weaviate is not offered on the Free plan; it runs on the paid sizes below. The size sets the CPU, memory, storage ceiling and connection limit; the gateway refuses connections over the limit with a protocol error. Storage grows in steps up to the ceiling, and you can resize at any time.

Sizes available for Weaviate: vCPU, memory, storage ceiling, connection limit and monthly price
Size	vCPU	Memory	Max storage	Max connections	≈ $ / month
`s0`	0.25	1 GiB	20 GB	60	$10
`s1`	0.5	2 GiB	50 GB	100	$15
`s2`	1	4 GiB	200 GB	200	$60
`m2`	2	8 GiB	500 GB	400	$110
`m4`	4	16 GiB	1 TB	800	$210
`l8`	8	32 GiB	4 TB	1,500	$410
`l16`	16	64 GiB	8 TB	3,000	$960
`xl32`	32	128 GiB	16 TB	5,000	$1,870

Full details, including hourly prices and burst CPU, are in the size catalogue; plan quotas are in limits and quotas.

Vector indexes (HNSW by default) live in memory, so memory decides how many objects fit; use product or binary quantization, or the flat index for small tenants, to reduce it. Modules that call external model APIs (text2vec-*, generative-*) are not enabled.

Licence

Databasezy runs Weaviate under the BSD-3-Clause licence, as listed in the engine catalogue. Your data and schemas are yours whatever the server's licence; the licence governs the server software we run.

Weaviate is BSD-3-Clause. Weaviate Cloud features, such as embedding services and the managed multi-node cluster, are not included.

Security

TLS on every connection. TLS 1.2 is the minimum and TLS 1.3 is preferred; plaintext is never offered. Verify the server, not just the encryption: use HTTPS with certificate verification. See TLS and the CA bundle.
IP allow-list. The gateway checks the client address before authentication, on every plan. Manage it under Network → Allow-list in the portal or with PUT /v1/orgs/{org}/instances/{id}/network.
Credentials. Generated inside the cell, shown once, never stored by the control plane. Rotate them with an overlap window so nothing breaks.
Secure hosting. Secure placement (HIPAA-ready) is a per-instance option once your organization has signed the BAA: dedicated nodes, customer-managed keys and immutable backups. See Secure hosting and the BAA.
Staff access. Databasezy staff cannot read your data without a grant you issue. See data confidentiality.

FAQ

Do I need to open the gRPC endpoint?

Yes, for the v4 Python and v3 TypeScript clients. Both endpoints use port 443 and TLS; the gRPC one has its own -grpc hostname, so allow both hostnames through any egress firewall on your side.

Can Weaviate create embeddings for me?

No. No vectorizer modules are enabled, so send vectors with your objects and queries.

Which Weaviate versions can I run?

The newest supported minor (the default) and the one before it; Weaviate supports its three latest minors. Weaviate is upgraded one minor at a time, so an instance moves to the next minor in place and keeps its data.

Is Weaviate on the Free plan?

No. It is a paid-plan engine.