Property data types

When creating a property, you must specify a data type. Weaviate accepts the following types.

Further details on each data type are provided below.

Use this type for any text data.

• Properties with the text type is used for vectorization and keyword search unless specified otherwise in the property settings.
• If using named vectors, the property vectorization is defined in the named vector definition.
• Text properties are tokenized prior to being indexed for keyword/BM25 searches. See collection definition: tokenization for more information.

from weaviate.classes.config import Property, DataType, Configure, Tokenization

import { vectors, dataType, tokenization } from 'weaviate-client';

# Create an object
example_object = {
    "title": "Rogue One",
    "movie_id": "ro123456",
    "genres": ["Action", "Adventure", "Sci-Fi"],
}

obj_uuid = my_collection.data.insert(example_object)

const exampleObject = {
  title: 'Rogue One',
  movie_id: 'ro123456',
  genres: ['Action', 'Adventure', 'Sci-Fi'],
}

const obj_uuid = await myCollection.data.insert(exampleObject);

The boolean, int, and number types are used for storing boolean, integer, and floating-point numbers, respectively.

from weaviate.classes.config import Property, DataType

import { dataType } from 'weaviate-client';

# Create an object
example_object = {
    "name": "Wireless Headphones",
    "price": 95.50,
    "stock_quantity": 100,
    "is_on_sale": True,
    "customer_ratings": [4.5, 4.8, 4.2],
}

obj_uuid = my_collection.data.insert(example_object)

const exampleObject = {
  name: 'Wireless Headphones',
  price: 95.5,
  stock_quantity: 100,
  is_on_sale: true,
  customer_ratings: [4.5, 4.8, 4.2],
};

const obj_uuid = await myCollection.data.insert(exampleObject);

Although Weaviate supports int64, GraphQL currently only supports int32, and does not support int64. This means that currently integer data fields in Weaviate with integer values larger than int32, will not be returned using GraphQL queries. We are working on solving this issue. As current workaround is to use a string instead.

A date in Weaviate is represented by an RFC 3339 timestamp in the date-time format. The timestamp includes the time and an offset.

For example:

• "1985-04-12T23:20:50.52Z"
• "1996-12-19T16:39:57-08:00"
• "1937-01-01T12:00:27.87+00:20"

To add a list of dates as a single entity, use an array of date-time formatted strings. For example: ["1985-04-12T23:20:50.52Z", "1937-01-01T12:00:27.87+00:20"]

In specific client libraries, you may be able to use the native date object as shown in the following examples.

from weaviate.classes.config import Property, DataType
from datetime import datetime, timezone

import { dataType } from 'weaviate-client';

# Create an object
# In Python, you can use the RFC 3339 format or a datetime object (preferably with a timezone)
example_object = {
    "artist": "Taylor Swift",
    "tour_name": "Eras Tour",
    "tour_start": datetime(2023, 3, 17).replace(tzinfo=timezone.utc),
    "tour_dates": [
        # Use `datetime` objects with a timezone
        datetime(2023, 3, 17).replace(tzinfo=timezone.utc),
        datetime(2023, 3, 18).replace(tzinfo=timezone.utc),
        # .. more dates
        # Or use RFC 3339 format
        "2024-12-07T00:00:00Z",
        "2024-12-08T00:00:00Z",
    ],
}

obj_uuid = my_collection.data.insert(example_object)

const exampleObject = {
  name: 'Taylor Swift',
  tour_name: 'Eras Tour',
  tour_start: new Date(2023, 3, 17),
  // Use JavaScript Date object
  tour_dates: [
    new Date(2023, 3, 17),
    new Date(2023, 3, 18),
    // .. more dates
    new Date(2024, 12, 6),
    new Date(2024, 12, 7),
  ],
  // // Or, use RFC3339 string
  // tour_dates: [
  //   '2023-03-17T00:00:00Z',
  //   '2023-03-18T00:00:00Z',
  //   // .. more dates
  //   '2024-12-07T00:00:00Z',
  //   '2024-12-08T00:00:00Z',
  // ]
};

const obj_uuid = await myCollection.data.insert(exampleObject);

The dedicated uuid and uuid[] data types efficiently store UUIDs.

• Each uuid is a 128-bit (16-byte) number.
• The filterable index uses roaring bitmaps.

from weaviate.classes.config import Property, DataType
from weaviate.util import generate_uuid5

import { dataType } from 'weaviate-client';
import { generateUuid5 } from 'weaviate-client';

# Create an object
example_object = {
    "title": "The Matrix",
    "movie_uuid": generate_uuid5("The Matrix"),
    "related_movie_uuids": [
        generate_uuid5("The Matrix Reloaded"),
        generate_uuid5("The Matrix Revolutions"),
        generate_uuid5("Matrix Resurrections"),
    ],
}

obj_uuid = my_collection.data.insert(example_object)

const exampleObject = {
  title: 'The Matrix',
  movie_uuid: generateUuid5('The Matrix'),
  related_movie_uuids: [
    generateUuid5('The Matrix Reloaded'),
    generateUuid5('The Matrix Revolutions'),
    generateUuid5('The Matrix Resurrections'),
  ],
};

const obj_uuid = await myCollection.data.insert(exampleObject);

Geo coordinates can be used to find objects in a radius around a query location. A geo coordinate value stored as a float, and is processed as decimal degree according to the ISO standard.

To supply a geoCoordinates property, specify the latitude and longitude as floating point decimal degrees.

import GeoTypePy from '!!raw-loader!/_includes/code/python/config-refs.datatypes.geocoordinates.py'; import GeoTypeTs from '!!raw-loader!/_includes/code/typescript/config-refs.datatypes.geocoordinates.ts';

import GeoLimitations from '/_includes/geo-limitations.mdx';

A phoneNumber input will be normalized and validated, unlike the single fields as number and string. The data field is an object with multiple fields.

{
  "phoneNumber": {
    "input": "020 1234567",                       // Required. Raw input in string format
    "defaultCountry": "nl",                       // Required if only a national number is provided, ISO 3166-1 alpha-2 country code. Only set if explicitly set by the user.
    "internationalFormatted": "+31 20 1234567",   // Read-only string
    "countryCode": 31,                            // Read-only unsigned integer, numerical country code
    "national": 201234567,                        // Read-only unsigned integer, numerical representation of the national number
    "nationalFormatted": "020 1234567",           // Read-only string
    "valid": true                                 // Read-only boolean. Whether the parser recognized the phone number as valid
  }
}

There are two fields that accept input. input must always be set, while defaultCountry must only be set in specific situations. There are two scenarios possible:

• When you enter an international number (e.g. "+31 20 1234567") to the input field, no defaultCountry needs to be entered. The underlying parser will automatically recognize the number's country.
• When you enter a national number (e.g. "020 1234567"), you need to specify the country in defaultCountry (in this case, "nl"), so that the parse can correctly convert the number into all formats. The string in defaultCountry should be an ISO 3166-1 alpha-2 country code.

Weaviate will also add further read-only fields such as internationalFormatted, countryCode, national, nationalFormatted and valid when reading back a field of type phoneNumber.

from weaviate.classes.config import Property, DataType
from weaviate.classes.data import PhoneNumber

import { dataType } from 'weaviate-client';

# Create an object
example_object = {
    "name": "Ray Stantz",
    "phone": PhoneNumber(number="212 555 2368", default_country="us"),
}

obj_uuid = my_collection.data.insert(example_object)

const exampleObject = {
  name: 'Ray Stantz',
  phone: {
    number: '212 555 2368',
    defaultCountry: 'us'
  }
};

const obj_uuid = await myCollection.data.insert(exampleObject);

The datatype blob accepts any binary data. The data should be base64 encoded, and passed as a string. Characteristics:

• Weaviate doesn't make assumptions about the type of data that is encoded. A module (e.g. img2vec) can investigate file headers as it wishes, but Weaviate itself does not do this.
• When storing, the data is base64 decoded (so Weaviate stores it more efficiently).
• When serving, the data is base64 encoded (so it is safe to serve as json).
• There is no max file size limit.
• This blob field is always skipped in the inverted index, regardless of setting. This mean you can not search by this blob field in a Weaviate GraphQL where filter, and there is no valueBlob field accordingly. Depending on the module, this field can be used in module-specific filters (e.g. nearImage in the img2vec-neural filter).

To obtain the base64-encoded value of an image, you can run the following command - or use the helper methods in the Weaviate clients - to do so:

cat my_image.png | base64

import BlobTypePy from '!!raw-loader!/_includes/code/python/config-refs.datatypes.blob.py'; import BlobTypeTs from '!!raw-loader!/_includes/code/typescript/config-refs.datatypes.blob.ts';

:::info Added in v1.37 :::

The blobHash data type accepts base64-encoded data (same as blob) but stores only a SHA-256 hash on disk. This reduces storage space while still allowing modules (such as multi2vec-google) to vectorize the original media content during import.

How it works:

• During validation, the base64 input is validated but kept as-is.
• The raw data flows through the vectorization pipeline so modules can vectorize the actual media content.
• After vectorization, the base64 data is converted to a SHA-256 hex hash before being persisted.
• When an object is updated, the incoming base64 data is hashed before being compared against the stored hash to determine whether re-vectorization is needed.

Behavior: identical to blob for indexing restrictions (no indexFilterable), sorting (string comparator), API serialization (GraphQL string, gRPC blob value), and inverted index exclusion.

{
  "properties": [
    {
      "name": "image",
      "dataType": ["blobHash"]
    }
  ]
}

Use blobHash when you need a vectorizer to see the raw media at import time but don't need to retrieve the original bytes afterwards: only the hash is stored.

The object type allows you to store nested data as a JSON object that can be nested to any depth.

For example, a Person collection could have an address property as an object. It could in turn include nested properties such as street and city:

from weaviate.classes.config import Property, DataType

import { dataType } from 'weaviate-client';

# Create an object
example_object = {
    "name": "John Smith",
    "home_address": {
        "street": {
            "number": 123,
            "name": "Main Street",
        },
        "city": "London",
    },
    "office_addresses": [
        {
            "office_name": "London HQ",
            "street": {"number": 456, "name": "Oxford Street"},
        },
        {
            "office_name": "Manchester Branch",
            "street": {"number": 789, "name": "Piccadilly Gardens"},
        },
    ],
}

obj_uuid = my_collection.data.insert(example_object)

const exampleObject = {
  name: 'John Smith',
  home_address: {
    street: {
      number: 123,
      name: 'Main Street',
    },
    city: 'London',
  },
  office_addresses: [
    {
      office_name: 'London HQ',
      street: { number: 456, name: 'Oxford Street' },
    },
    {
      office_name: 'Manchester Branch',
      street: { number: 789, name: 'Piccadilly Gardens' },
    },
  ],
};

const obj_uuid = await myCollection.data.insert(exampleObject);

import CrossReferencePerformanceNote from '/_includes/cross-reference-performance-note.mdx';

The cross-reference type allows a link to be created from one object to another. This is useful for creating relationships between collections, such as linking a Person collection to a Company collection.

The cross-reference type objects are arrays by default. This allows you to link to any number of instances of a given collection (including zero).

For more information on cross-references, see the cross-references. To see how to work with cross-references, see how to manage data: cross-references.

In raw payloads (e.g. JSON payloads for REST), data types are specified as an array (e.g. ["text"], or ["text[]"]), as it is required for some cross-reference specifications.

• How-to: Manage collections
• Concepts: Data structure
• References: REST API: Schema

import DocsFeedback from '/_includes/docs-feedback.mdx';