When [creating a property](../how-to-manage-collections/collection-operations.md#add-a-property), you must specify a data type. Weaviate accepts the following types.

## Available data types

:::callout{intent="note" title="Array types"}
Arrays of a data type are specified by adding `[]` to the type (e.g. `text` ➡ `text[]`). Note that not all data types support arrays.
:::

| Name                                              | Exact type                                               | Formatting                                | Array (`[]`) available (example)                                                     | Note                  |
| ------------------------------------------------- | -------------------------------------------------------- | ----------------------------------------- | ------------------------------------------------------------------------------------ | --------------------- |
| [text](datatypes.md#text)                         | string                                                   | `string`                                  | ✅ `["string one", "string two"]`                                                     |                       |
| [boolean](datatypes.md#boolean--int--number)      | boolean                                                  | `true`/`false`                            | ✅ `[true, false]`                                                                    |                       |
| [int](datatypes.md#boolean--int--number)          | int64 (see [notes](datatypes.md#note-graphql-and-int64)) | `123`                                     | ✅ `[123, -456]`                                                                      |                       |
| [number](datatypes.md#boolean--int--number)       | float64                                                  | `0.0`                                     | ✅ `[0.0, 1.1]`                                                                       |                       |
| [date](datatypes.md#date)                         | string                                                   | [more info](datatypes.md#date)            | ✅                                                                                    |                       |
| [uuid](datatypes.md#uuid)                         | string                                                   | `"c8f8176c-6f9b-5461-8ab3-f3c7ce8c2f5c"`  | ✅ `["c8f8176c-6f9b-5461-8ab3-f3c7ce8c2f5c", "36ddd591-2dee-4e7e-a3cc-eb86d30a4303"]` |                       |
| [geoCoordinates](datatypes.md#geocoordinates)     | string                                                   | [more info](datatypes.md#geocoordinates)  | ❌                                                                                    |                       |
| [phoneNumber](datatypes.md#phonenumber)           | string                                                   | [more info](datatypes.md#phonenumber)     | ❌                                                                                    |                       |
| [blob](datatypes.md#blob)                         | base64 encoded string                                    | [more info](datatypes.md#blob)            | ❌                                                                                    |                       |
| [blobHash](datatypes.md#blobhash)                 | base64 encoded string (stored as SHA-256 hash)           | [more info](datatypes.md#blobhash)        | ❌                                                                                    | Available from `1.37` |
| [object](datatypes.md#object)                     | object                                                   | `{"child": "I'm nested!"}`                | ✅ `[{"child": "I'm nested!"}, {"child": "I'm nested too!"}`                          | Available from `1.22` |
| [_cross reference_](datatypes.md#cross-reference) | string                                                   | [more info](datatypes.md#cross-reference) | ❌                                                                                    |                       |

:::accordion{title="Deprecated types"}
| Name   | Exact type | Formatting | Array available (example)       | Deprecated from |
| ------ | ---------- | ---------- | ------------------------------- | --------------- |
| string | string     | `"string"` | ✅ `["string", "second string"]` | `v1.19`         |
:::

Further details on each data type are provided below.

## `text`

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](../how-to-manage-collections/vector-config.md#property-level-settings).
- If using [named vectors](../concepts/data.md#multiple-vector-embeddings-named-vectors), the property vectorization is defined in the [named vector definition](../how-to-manage-collections/vector-config.md#define-named-vectors).
- Text properties are tokenized prior to being indexed for keyword/BM25 searches. See [collection definition: tokenization](collections.md#tokenization) for more information.

:::accordion{title="string is deprecated"}
Prior to `v1.19`, Weaviate supported an additional datatype `string`, which was differentiated by tokenization behavior to `text`. As of `v1.19`, this type is deprecated and will be removed in a future release.

Use `text` instead of `string`. `text` supports the tokenization options that are available through `string`.
:::

### Examples

#### Property definition

:::code-group{sync="languages"}
```python title="Python"
from weaviate.classes.config import Property, DataType, Configure, Tokenization
```

```typescript title="JavaScript/TypeScript"
import { vectors, dataType, tokenization } from 'weaviate-client';
```
:::

#### Object insertion

:::code-group{sync="languages"}
```python title="Python"
# Create an object
example_object = {
    "title": "Rogue One",
    "movie_id": "ro123456",
    "genres": ["Action", "Adventure", "Sci-Fi"],
}

obj_uuid = my_collection.data.insert(example_object)
```

```typescript title="JavaScript/TypeScript"
const exampleObject = {
  title: 'Rogue One',
  movie_id: 'ro123456',
  genres: ['Action', 'Adventure', 'Sci-Fi'],
}

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

## `boolean` / `int` / `number`

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

### Examples

#### Property definition

:::code-group{sync="languages"}
```python title="Python"
from weaviate.classes.config import Property, DataType
```

```typescript title="JavaScript/TypeScript"
import { dataType } from 'weaviate-client';
```
:::

#### Object insertion

:::code-group{sync="languages"}
```python title="Python"
# 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)
```

```typescript title="JavaScript/TypeScript"
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);
```
:::

### Note: GraphQL and `int64`

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](https://github.com/weaviate/weaviate/issues/1563). As current workaround is to use a `string` instead.

## `date`

A `date` in Weaviate is represented by an [RFC 3339](https://datatracker.ietf.org/doc/rfc3339/) 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.

### Examples

#### Property definition

:::code-group{sync="languages"}
```python title="Python"
from weaviate.classes.config import Property, DataType
from datetime import datetime, timezone
```

```typescript title="JavaScript/TypeScript"
import { dataType } from 'weaviate-client';
```
:::

#### Object insertion

:::code-group{sync="languages"}
```python title="Python"
# 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)
```

```typescript title="JavaScript/TypeScript"
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);
```
:::

## `uuid`

The dedicated `uuid` and `uuid[]` data types efficiently store [UUIDs](https://en.wikipedia.org/wiki/Universally_unique_identifier).

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

:::callout{intent="note" title="Aggregate/sort currently not possible"}
It is currently not possible to aggregate or sort by `uuid` or `uuid[]` types.
:::

### Examples

#### Property definition

:::code-group{sync="languages"}
```python title="Python"
from weaviate.classes.config import Property, DataType
from weaviate.util import generate_uuid5
```

```typescript title="JavaScript/TypeScript"
import { dataType } from 'weaviate-client';
import { generateUuid5 } from 'weaviate-client';
```
:::

#### Object insertion

:::code-group{sync="languages"}
```python title="Python"
# 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)
```

```typescript title="JavaScript/TypeScript"
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);
```
:::

## `geoCoordinates`

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](https://en.wikipedia.org/wiki/Decimal_degrees) according to the [ISO standard](https://www.iso.org/standard/39242.html#:~\:text=For%20computer%20data%20interchange%20of,minutes%2C%20seconds%20and%20decimal%20seconds).

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

<!-- An example of how geo coordinates are used in a data object:

```json
{
  "City": {
    "location": {
      "latitude": 52.366667,
      "longitude": 4.9
    }
  }
}
``` -->

### Examples

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';

#### Property definition

<Tabs className="code" groupId="languages">
  <TabItem value="py" label="Python">
    <FilteredTextBlock
      text={GeoTypePy}
      startMarker="# START ConfigureDataType"
      endMarker="# END ConfigureDataType"
      language="py"
    />
  </TabItem>
  <TabItem value="ts" label="JavaScript/TypeScript">
    <FilteredTextBlock
      text={GeoTypeTs}
      startMarker="// START ConfigureDataType"
      endMarker="// END ConfigureDataType"
      language="ts"
    />
  </TabItem>
</Tabs>

#### Object insertion

<Tabs className="code" groupId="languages">
  <TabItem value="py" label="Python">
    <FilteredTextBlock
      text={GeoTypePy}
      startMarker="# START AddObject"
      endMarker="# END AddObject"
      language="py"
    />
  </TabItem>
  <TabItem value="ts" label="JavaScript/TypeScript">
    <FilteredTextBlock
      text={GeoTypeTs}
      startMarker="// START AddObject"
      endMarker="// END AddObject"
      language="ts"
    />
  </TabItem>
</Tabs>

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

<GeoLimitations/>

## `phoneNumber`

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.

```yaml
{
  "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](https://en.wikipedia.org/wiki/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`.

### Examples

#### Property definition

:::code-group{sync="languages"}
```python title="Python"
from weaviate.classes.config import Property, DataType
from weaviate.classes.data import PhoneNumber
```

```typescript title="JavaScript/TypeScript"
import { dataType } from 'weaviate-client';
```
:::

#### Object insertion

:::code-group{sync="languages"}
```python title="Python"
# 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)
```

```typescript title="JavaScript/TypeScript"
const exampleObject = {
  name: 'Ray Stantz',
  phone: {
    number: '212 555 2368',
    defaultCountry: 'us'
  }
};

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

## `blob`

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).

<!-- Example:

The dataType `blob` can be used as property dataType in the data schema as follows:

```json
{
  "properties": [
    {
      "name": "image",
      "dataType": ["blob"]
    }
  ]
}
``` -->

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:

```bash
cat my_image.png | base64
```

<!-- You can then import data with `blob` dataType to Weaviate as follows:

```bash
curl \
    -X POST \
    -H "Content-Type: application/json" \
    -d '{
      "class": "FashionPicture",
      "id": "36ddd591-2dee-4e7e-a3cc-eb86d30a4302",
      "properties": {
          "image": "iVBORw0KGgoAAAANS..."
      }
  }' \
    http://localhost:8080/v1/objects
``` -->

### Examples

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';

#### Property definition

<Tabs className="code" groupId="languages">
  <TabItem value="py" label="Python">
    <FilteredTextBlock
      text={BlobTypePy}
      startMarker="# START ConfigureDataType"
      endMarker="# END ConfigureDataType"
      language="py"
    />
  </TabItem>
  <TabItem value="ts" label="JavaScript/TypeScript">
    <FilteredTextBlock
      text={BlobTypeTs}
      startMarker="// START ConfigureDataType"
      endMarker="// END ConfigureDataType"
      language="ts"
    />
  </TabItem>
</Tabs>

#### Object insertion

<Tabs className="code" groupId="languages">
  <TabItem value="py" label="Python">
    <FilteredTextBlock
      text={BlobTypePy}
      startMarker="# START AddObject"
      endMarker="# END AddObject"
      language="py"
    />
  </TabItem>
  <TabItem value="ts" label="JavaScript/TypeScript">
    <FilteredTextBlock
      text={BlobTypeTs}
      startMarker="// START AddObject"
      endMarker="// END AddObject"
      language="ts"
    />
  </TabItem>
</Tabs>

## `blobHash`

\:::info Added in `v1.37`
\:::

The `blobHash` data type accepts base64-encoded data (same as [`blob`](#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.

```json
{
  "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.

## `object`

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`:

:::callout{intent="note" title="Indexing and filtering"}
`object` and `object[]` properties are not vectorized by default, and only their leaf scalars are stored in the inverted index. If you list an object property in the vector configuration's [`properties` field](indexing-vector-index.md#specify-which-properties-to-vectorize), it is converted to a string (its JSON representation) and concatenated into the vectorizer's input text. From Weaviate `v1.38` (preview), you can filter on nested-object leaves using a dotted path syntax. See [Filter on nested object properties](../how-to-query-search/filters.md#filter-on-nested-object-properties).
:::

### Examples

#### Property definition

:::code-group{sync="languages"}
```python title="Python"
from weaviate.classes.config import Property, DataType
```

```typescript title="JavaScript/TypeScript"
import { dataType } from 'weaviate-client';
```
:::

#### Object insertion

:::code-group{sync="languages"}
```python title="Python"
# 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)
```

```typescript title="JavaScript/TypeScript"
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);
```
:::

<!-- Old example - could re-use for other language examples -->

<!--
```json
{
    "class": "Person",
    "properties": [
        {
            "dataType": ["text"],
            "name": "last_name",
        },
        {
            "dataType": ["object"],
            "name": "address",
            "nestedProperties": [
                {"dataType": ["text"], "name": "street"},
                {"dataType": ["text"], "name": "city"}
            ],
        }
    ],
}
```

An object for this class may have a structure such as follows:

```json
{
    "last_name": "Franklin",
    "address": {
        "city": "London",
        "street": "King Street"
    }
}
``` -->

## `cross-reference`

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

<CrossReferencePerformanceNote />

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](../concepts/data.md#cross-references). To see how to work with cross-references, see [how to manage data: cross-references](../manage-collections/cross-references.mdx).

## Notes

#### Formatting in payloads

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.

## Further resources

- [How-to: Manage collections](../manage-collections/index.mdx)
- [Concepts: Data structure](../concepts/data.md)
- <SkipLink href="/weaviate/api/rest#tag/schema">References: REST API: Schema</SkipLink>

## Questions and feedback

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

<DocsFeedback/>

## Related pages

- [Agents](./agents-index.md)
- [AI-assisted Weaviate code generation](./ai-assisted-vibe-coding-index.md)
- [APIs](./apis-index.md)
- [Authorization and authentication](./authorization-and-authentication-index.md)
- [Benchmarks](./benchmarks-index.md)
- [Best practices](./best-practices-index.md)
- [Client libraries](./clients-index.md)
- [Client Libraries / SDKs](./client-libraries-index.md)
- [Cloud](./cloud-index.md)
- [Cloud account management](./cloud-account-management-index.md)

# Agent Instructions

This portal answers questions programmatically. To receive a synthesized,
source-cited answer instead of crawling page by page, append the `?ask=`
query parameter to any page URL on this site:

    /guides/quickstart?ask=how+do+I+authenticate

Optional parameters:

- `&goal=<what-you-are-trying-to-do>` steers the answer toward your
  objective (e.g. `&goal=write+a+python+client`).
- `&version=<label>` scopes the answer to a mounted version when the
  portal publishes more than one.

The response is `text/markdown`: the answer followed by a `# Sources` list
of the portal pages it was grounded in. Status codes are the contract:

- `200` — the answer; `402` — the portal owner’s plan or answer credits are
  exhausted (surface this to your operator; do NOT retry); `429` — you are
  rate-limited; back off for the `Retry-After` seconds; `503` — the answer
  lane is temporarily unavailable; fall back to crawling the `.md` pages.

For the full corpus map read `llms.txt` at the site root; for the tool
surface (search + page fetch as MCP tools) see `/mcp`.