---
title: "Create objects"
description: "How to create objects in Weaviate with code examples in Python, TypeScript, Go, Java, and C#."
url: https://docs.weaviate.io/weaviate/manage-objects/create
---

# Create objects

The examples on this page demonstrate how to create individual objects in Weaviate.

> [!TIP]
>
> **Use batch import for multiple objects**
>
> For creating multiple objects at once, see [How-to: Batch Import](https://docs.weaviate.io/weaviate/manage-objects/import).

## Create an object

This example creates an object in the `JeopardyQuestion` collection.

**Python**

```py
jeopardy = client.collections.use("JeopardyQuestion")

uuid = jeopardy.data.insert({
    "question": "This vector DB is OSS & supports automatic property type inference on import",
    # "answer": "Weaviate",  # properties can be omitted
    "newProperty": 123,  # will be automatically added as a number property
})

print(uuid)  # the return value is the object's UUID
```

**JavaScript/TypeScript**

```ts
const jeopardy = client.collections.use('JeopardyQuestion')

uuid = await jeopardy.data.insert({
  'question': 'This vector DB is OSS & supports automatic property type inference on import',
  // 'answer': 'Weaviate',  // properties can be omitted
  'newProperty': 123,  // will be automatically added as a number property
})

console.log('UUID: ', uuid)
```

**Go (v5)**

```go
w, err := client.Data().Creator().
  WithClassName("JeopardyQuestion").
  WithProperties(map[string]interface{}{
  	"question": "This vector DB is OSS and supports automatic property type inference on import",
  	// "answer": "Weaviate", // schema properties can be omitted
  	"newProperty": 123, // will be automatically added as a number property
  }).
  Do(ctx)

// the returned value is a wrapped object
b, err := json.MarshalIndent(w.Object, "", "  ")
fmt.Println(string(b))
```

**Go (v6)**

```go
questions := client.Collections.Use("JeopardyQuestion")

res, err := questions.Data.Insert(ctx, &data.Object{
  Properties: map[string]any{
    "question": "This vector DB is OSS & supports automatic property type inference on import",
    // "answer": "Weaviate", // Properties can be omitted.
    "newProperty": 123, // Auto-schema adds this as a number property.
  },
})
if err != nil {
  // handle error
  panic(err)
}

fmt.Println(res.UUIDs[0]) // The id of the new object.
```

**Java**

```java
var jeopardy = client.collections.use("JeopardyQuestion");

var uuid = jeopardy.data.insert(Map.of(
    "question",
    "This vector DB is OSS & supports automatic property type inference on import",
    // "answer": "Weaviate", // properties can be omitted
    "newProperty", 123 // will be automatically added as a number property
)).uuid();

System.out.println(uuid); // the return value is the object's UUID
```

**C#**

```csharp
var jeopardy = client.Collections.Use("JeopardyQuestion");

var uuid = await jeopardy.Data.Insert(
    new
    {
        question = "This vector DB is OSS & supports automatic property type inference on import",
        // answer = "Weaviate", // properties can be omitted
        newProperty = 123, // will be automatically added as a number property
    }
);

Console.WriteLine(uuid); // the return value is the object's UUID
```

**Additional information**

To create an object, specify the following:

- The object data you want to add
- The target collection
- If [multi-tenancy](https://docs.weaviate.io/weaviate/concepts/data#multi-tenancy) is enabled, [specify the tenant](https://docs.weaviate.io/weaviate/manage-collections/multi-tenancy)

By default, [auto-schema](https://docs.weaviate.io/weaviate/config-refs/collections#auto-schema) creates new collections and adds new properties.

## Create an object with a specified vector

When you create an object, you can provide a vector. (For specifying multiple, named vectors, see [below](https://docs.weaviate.io/weaviate/manage-objects/create#create-an-object-with-named-vectors).)

**Python**

```py
jeopardy = client.collections.use("JeopardyQuestion")
uuid = jeopardy.data.insert(
    properties={
        "question": "This vector DB is OSS and supports automatic property type inference on import",
        "answer": "Weaviate",
    },
    vector=[0.12345] * 1536
)

print(uuid)  # the return value is the object's UUID
```

**JavaScript/TypeScript**

```ts
const jeopardy = client.collections.use('JeopardyQuestion')

uuid = await jeopardy.data.insert({
  properties: {
  'question': 'This vector DB is OSS & supports automatic property type inference on import',
  // 'answer': 'Weaviate',  // properties can be omitted
  'newProperty': 123,  // will be automatically added as a number property
  },
  vectors: Array(1536).fill(0.12345)
})

console.log('UUID: ', uuid)
```

**Go (v5)**

```go
vector := make([]float32, 1536)
for i := 0; i < len(vector); i++ {
  vector[i] = 0.12345
}

w, err := client.Data().Creator().
  WithClassName("JeopardyQuestion").
  WithProperties(map[string]interface{}{
  	"question": "This vector DB is OSS and supports automatic property type inference on import",
  	"answer":   "Weaviate",
  }).
  WithVector(vector).
  Do(ctx)

// the returned value is a wrapped object
b, err := json.MarshalIndent(w.Object, "", "  ")
// CreateObjectWithId END
require.NoError(t, err)
fmt.Println(string(b))
// CreateObjectWithId END
})

t.Run("create object with id and vector", func(t *testing.T) {
// CreateObjectWithId START
vector := make([]float32, 1536)
for i := 0; i < len(vector); i++ {
  vector[i] = 0.12345
}

w, err := client.Data().Creator().
  WithClassName("JeopardyQuestion").
  WithProperties(map[string]interface{}{
  	"question": "This vector DB is OSS and supports automatic property type inference on import",
  	"answer":   "Weaviate",
  }).
  WithID("12345678-e64f-5d94-90db-c8cfa3fc1234").
  Do(ctx)

// CreateObjectWithId END

require.NoError(t, err)

// CreateObjectWithId START
// the returned value is a wrapped object
b, err := json.MarshalIndent(w.Object, "", "  ")
// CreateObjectWithId END
require.NoError(t, err)
// CreateObjectWithId START
fmt.Println(string(b))
// CreateObjectWithId END
})

t.Run("create object with deterministic id", func(t *testing.T) {
// CreateObjectWithDeterministicIdTODO START
properties := map[string]interface{}{
  "question": "This vector DB is OSS and supports automatic property type inference on import",
  "answer":   "Weaviate",
}

// String id = "gen_uuid5(properties)"; // TODO implement
id := "17f91943-1a5e-46d3-9323-a1cdb735591c"

w, err := client.Data().Creator().
  WithClassName("JeopardyQuestion").
  WithProperties(properties).
  WithID(id).
  Do(ctx)

// CreateObjectWithDeterministicIdTODO END

require.NoError(t, err)

// CreateObjectWithDeterministicIdTODO START
// the returned value is a wrapped object
b, err := json.MarshalIndent(w.Object, "", "  ")
// CreateObjectWithDeterministicIdTODO END
require.NoError(t, err)
// CreateObjectWithDeterministicIdTODO START
fmt.Println(string(b))
// CreateObjectWithDeterministicIdTODO END
})

t.Run("validate object", func(t *testing.T) {
// ValidateObject START
err := client.Data().Validator().
  WithClassName("JeopardyQuestion").
  WithProperties(map[string]interface{}{
  	"question":                          "This vector DB is OSS and supports automatic property type inference on import",
  	"answer":                            "Weaviate",
  	"thisPropShouldNotEndUpInTheSchema": -1,
  }).
  WithID("12345678-1234-1234-1234-123456789012").
  Do(ctx)

// ValidateObject END

require.Error(t, err)

// ValidateObject START
assert.ErrorContains(t, err, "invalid object: no such prop with name 'thisPropShouldNotEndUpInTheSchema' found")
// ValidateObject END
})
}
```

**Go (v6)**

```go
questions := client.Collections.Use("JeopardyQuestion")

res, err := questions.Data.Insert(ctx, &data.Object{
  Properties: map[string]any{
    "question": "This vector DB is OSS and supports automatic property type inference on import",
    "answer":   "Weaviate",
  },
  Vectors: []types.Vector{
    {Name: "default", Single: []float32{0.12345, 0.6789, 0.9876}},
  },
})
if err != nil {
  // handle error
  panic(err)
}

fmt.Println(res.UUIDs[0]) // The id of the new object.
```

**Java**

```java
var jeopardy = client.collections.use("JeopardyQuestion");
var uuid = jeopardy.data.insert(Map.of("question",
    "This vector DB is OSS and supports automatic property type inference on import",
    "answer", "Weaviate"),
    meta -> meta.vectors(Vectors.of(new float[384])) // Using a zero vector for demonstration
).uuid();

System.out.println(uuid); // the return value is the object's UUID
```

**C#**

```csharp
var jeopardy = client.Collections.Use("JeopardyQuestion");
var uuid = await jeopardy.Data.Insert(
    new
    {
        question = "This vector DB is OSS and supports automatic property type inference on import",
        answer = "Weaviate",
    },
    vectors: new float[300] // Using a zero vector for demonstration
);

Console.WriteLine(uuid); // the return value is the object's UUID
```

## Create an object with named vectors

When you create an object, you can specify named vectors (if [configured in your collection](https://docs.weaviate.io/weaviate/manage-collections/vector-config#define-named-vectors)).

**Python**

```py
reviews = client.collections.use("WineReviewNV")  # This collection must have named vectors configured
uuid = reviews.data.insert(
    properties={
        "title": "A delicious Riesling",
        "review_body": "This wine is a delicious Riesling which pairs well with seafood.",
        "country": "Germany",
    },
    # Specify the named vectors, following the collection definition
    vector={
        "title": [0.12345] * 1536,
        "review_body": [0.31313] * 1536,
        "title_country": [0.05050] * 1536,
    }
)

print(uuid)  # the return value is the object's UUID
```

**JavaScript/TypeScript**

```ts
const reviews = client.collections.use('WineReviewNV')

uuid = await reviews.data.insert({
  properties: {
    'title': 'A delicious Riesling',
    'review_body': 'This wine is a delicious Riesling which pairs well with seafood.',
    'country': 'Germany',
  },
  vectors: {
    title: Array(1536).fill(0.12345),
    review_body: Array(1536).fill(0.31313),
    title_country: Array(1536).fill(0.05050),
  }
})

console.log('UUID: ', uuid)
```

**Java**

```java
var reviews = client.collections.use("WineReviewNV"); // This collection must have named vectors configured
var uuid = reviews.data.insert(
    Map.of("title", "A delicious Riesling", "review_body",
        "This wine is a delicious Riesling which pairs well with seafood.",
        "country", "Germany"),
    // Specify the named vectors, following the collection definition
    meta -> meta.vectors(Vectors.of("title", new float[1536]),
        Vectors.of("review_body", new float[1536]),
        Vectors.of("title_country", new float[1536]))
).uuid();

System.out.println(uuid); // the return value is the object's UUID
```

**C#**

```csharp
var reviews = client.Collections.Use("WineReviewNV"); // This collection must have named vectors configured
var uuid = await reviews.Data.Insert(
    new
    {
        title = "A delicious Riesling",
        review_body = "This wine is a delicious Riesling which pairs well with seafood.",
        country = "Germany",
    },
    // Specify the named vectors, following the collection definition
    vectors: new Vectors
    {
        { "title", new float[1536] },
        { "review_body", new float[1536] },
        { "title_country", new float[1536] },
    }
);

Console.WriteLine(uuid); // the return value is the object's UUID
```

## Create an object with a specified ID

When you create an object, you can specify an [ID](https://docs.weaviate.io/weaviate/api/graphql/additional-properties#id).

> [!NOTE]
>
> If no ID is provided, Weaviate will generate a random [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier).

**Python**

```py
properties = {
    "question": "This vector DB is OSS and supports automatic property type inference on import",
    "answer": "Weaviate",
}
jeopardy = client.collections.use("JeopardyQuestion")
uuid = jeopardy.data.insert(
    properties=properties,
    uuid="12345678-e64f-5d94-90db-c8cfa3fc1234"
)

print(uuid)  # the return value is the object's UUID
```

**JavaScript/TypeScript**

```ts
const jeopardy = client.collections.use('JeopardyQuestion')

uuid = await jeopardy.data.insert({
  properties: {
    'question': 'This vector DB is OSS and supports automatic property type inference on import',
    'answer': 'Weaviate',
  },
  id: '12345678-e64f-5d94-90db-c8cfa3fc1234'
})

console.log('UUID: ', uuid)
```

**Go (v5)**

```go
vector := make([]float32, 1536)
for i := 0; i < len(vector); i++ {
  vector[i] = 0.12345
}

w, err := client.Data().Creator().
  WithClassName("JeopardyQuestion").
  WithProperties(map[string]interface{}{
  	"question": "This vector DB is OSS and supports automatic property type inference on import",
  	"answer":   "Weaviate",
  }).
  WithID("12345678-e64f-5d94-90db-c8cfa3fc1234").
  Do(ctx)

// the returned value is a wrapped object
b, err := json.MarshalIndent(w.Object, "", "  ")
fmt.Println(string(b))
```

**Go (v6)**

```go
questions := client.Collections.Use("JeopardyQuestion")

id := uuid.MustParse("12345678-e64f-5d94-90db-c8cfa3fc1234")
res, err := questions.Data.Insert(ctx, &data.Object{
  UUID: &id,
  Properties: map[string]any{
    "question": "This vector DB is OSS and supports automatic property type inference on import",
    "answer":   "Weaviate",
  },
})
if err != nil {
  // handle error
  panic(err)
}

fmt.Println(res.UUIDs[0]) // The id of the new object.
```

**Java**

```java
Map<String, Object> properties = new HashMap<>();
properties.put("question",
    "This vector DB is OSS and supports automatic property type inference on import");
properties.put("answer", "Weaviate");

var jeopardy = client.collections.use("JeopardyQuestion");
var uuid = jeopardy.data.insert(properties,
    meta -> meta.uuid("12345678-e64f-5d94-90db-c8cfa3fc1234")
).uuid();

System.out.println(uuid); // the return value is the object's UUID
```

**C#**

```csharp
var jeopardy = client.Collections.Use("JeopardyQuestion");
var uuid = await jeopardy.Data.Insert(
    new
    {
        question = "This vector DB is OSS and supports automatic property type inference on import",
        answer = "Weaviate",
    },
    uuid: Guid.Parse("12345678-e64f-5d94-90db-c8cfa3fc1234")
);

Console.WriteLine(uuid); // the return value is the object's UUID
```

## Generate deterministic IDs

You can generate an ID based on your data object.

> [!NOTE]
>
> A deterministic ID is not random: the same object value always generates the same ID.\
> Weaviate throws an error if you provide a duplicate ID. Use deterministic IDs to avoid inserting duplicate objects.

**Python**

```py
from weaviate.util import generate_uuid5  # Generate a deterministic ID

data_object = {
    "question": "This vector DB is OSS and supports automatic property type inference on import",
    "answer": "Weaviate",
}

jeopardy = client.collections.use("JeopardyQuestion")
uuid = jeopardy.data.insert(
    properties=data_object,
    uuid=generate_uuid5(data_object),
)
```

**JavaScript/TypeScript**

```ts
import { generateUuid5 } from '@weaviate/node';
const jeopardy = client.collections.use('JeopardyQuestion')

const dataObject = {
  'question': 'This vector DB is OSS and supports automatic property type inference on import',
  'answer': 'Weaviate',
}

const newUuid = generateUuid5('Article', JSON.stringify(dataObject)) // use the whole object to generate a uuid
uuid = await jeopardy.data.insert({
  properties: dataObject,
  id: newUuid
  // id: generateUuid5(dataObject.answer)                  // use a specific property to generate a uuid
})

console.log('UUID: ', uuid)
```

**Go (v5)**

```go
// This feature is under development
```

**Go (v6)**

```go
// Coming soon
```

**Java**

```java
// In Java, you can generate a deterministic UUID from a string or bytes.
// This helper function uses UUID.nameUUIDFromBytes for this purpose.

Map<String, Object> dataObject = new HashMap<>();
dataObject.put("question",
    "This vector DB is OSS and supports automatic property type inference on import");
dataObject.put("answer", "Weaviate");

var jeopardy = client.collections.use("JeopardyQuestion");
var uuid = jeopardy.data.insert(dataObject,
    meta -> meta.uuid(generateUuid5(dataObject.toString()).toString())
).uuid();
```

**C#**

```csharp
// In C#, you can generate a deterministic UUID from a string or bytes.
// This helper function creates a UUID v5 for this purpose.

var dataObject = new
{
    question = "This vector DB is OSS and supports automatic property type inference on import",
    answer = "Weaviate",
};
var dataObjectString = JsonSerializer.Serialize(dataObject);

var jeopardy = client.Collections.Use("JeopardyQuestion");
var uuid = await jeopardy.Data.Insert(
    dataObject,
    uuid: GenerateUuid5(dataObjectString)
);
```

**Additional information**

To generate deterministic IDs, use one of these methods:

- `generate_uuid5` (Python)
- `generateUuid5` (TypeScript)

## Create an object with cross-references

> [!WARNING]
>
> **Cross-references and query performance**
>
> Queries involving cross-references can be slower than queries that do not involve cross-references, especially at scale such as for multiple objects or complex queries.
>
> At the first instance, we strongly encourage you to consider whether you can avoid using cross-references in your data schema. As a scalable AI database, Weaviate is well-placed to perform complex queries with vector, keyword and hybrid searches involving filters. You may benefit from rethinking your data schema to avoid cross-references where possible.
>
> For example, instead of creating separate "Author" and "Book" collections with cross-references, consider embedding author information directly in Book objects and using searches and filters to find books by author characteristics.

You can create an object with cross-references to other objects.

**Python**

```py
questions = client.collections.use("JeopardyQuestion")

questions.data.insert(
    properties=properties,  # A dictionary with the properties of the object
    uuid=obj_uuid,  # The UUID of the object
    references={"hasCategory": category_uuid},  # e.g. {"hasCategory": "583876f3-e293-5b5b-9839-03f455f14575"}
)
```

**JavaScript/TypeScript**

```ts
const category = client.collections.use('JeopardyCategory')

const dataObject = {'name': 'Science'}

const response = await category.data.insert({
  properties: dataObject,
  references: {
    'hasCategory': categoryId  // e.g. {'hasCategory': '583876f3-e293-5b5b-9839-03f455f14575'}
  }
})

console.log('UUID: ', response)
```

**Java**

```java
var questions = client.collections.use("JeopardyQuestion");

var result = questions.data.insert(properties, // A map with the properties of the object
    opt -> opt
        .reference("hasCategory", ObjectReference.uuids(categoryUuid)) // e.g. {"hasCategory":
// "583876f3-e293-5b5b-9839-03f455f14575"}
);
```

**C#**

```csharp
```

> [!TIP]
>
> **Additional information**
>
> See [How-to: Cross-references](https://docs.weaviate.io/weaviate/manage-collections/cross-references) for more on working with cross-references.

## Create an object with `geoCoordinates`

> [!NOTE]
>
> **Limitations**
>
> Currently, geo-coordinate filtering is limited to the nearest 800 results from the source location, which will be further reduced by any other filter conditions and search parameters.
>
> If you plan on a densely populated dataset, consider using another strategy such as geo-hashing into a `text` datatype, and filtering further, such as with a `ContainsAny` filter.

If you want to supply a [`geoCoordinates`](https://docs.weaviate.io/weaviate/config-refs/datatypes#geocoordinates) property, you need to specify the `latitude` and `longitude` as floating point decimal degrees:

**Python**

```py
publications = client.collections.use("Publication")

publications.data.insert(
    properties={
        "headquartersGeoLocation": {
            "latitude": 52.3932696,
            "longitude": 4.8374263
        }
    },
)
```

**JavaScript/TypeScript**

```js
const publication = client.collections.use('Publication')

uuid = await publication.data.insert({
  properties: {
    name: 'Elsevier',
    headquartersGeoLocation: {
      'latitude': 52.3932696,
      'longitude': 4.8374263,
    },
  },
  id: 'df48b9f6-ba48-470c-bf6a-57657cb07390'
})

console.log('UUID: ', uuid)
```

**Go (v5)**

```go
package main

import (
  "context"
  "fmt"

  "github.com/weaviate/weaviate-go-client/v5/weaviate"
)

func main() {
  cfg := weaviate.Config{
    Host:   "localhost:8080",
    Scheme: "http",
  }
  client, err := weaviate.NewClient(cfg)
  if err != nil {
    panic(err)
  }

  dataSchema := map[string]interface{}{
    "name": "Elsevier",
    "headquartersGeoLocation": map[string]float32{
      "latitude":  52.3932696,
      "longitude": 4.8374263,
    },
  }

  created, err := client.Data().Creator().
    WithClassName("Publication").
    WithID("df48b9f6-ba48-470c-bf6a-57657cb07390").
    WithProperties(dataSchema).
    Do(context.Background())

  if err != nil {
    panic(err)
  }
  fmt.Printf("%v", created)
}
```

**Java**

```java
var publications = client.collections.use("Publication");

var uuid = publications.data
    .insert(Map.of("headquartersGeoLocation",
        Map.of("latitude", 52.3932696, "longitude", 4.8374263)))
    .uuid();
```

**C#**

```csharp
var publications = client.Collections.Use("Publication");

var uuid = await publications.Data.Insert(
    new { headquartersGeoLocation = new GeoCoordinate(52.3932696f, 4.8374263f) }
);
```

## Validate objects before creation

Before you create an object, you can [validate](https://docs.weaviate.io/weaviate/api/rest#tag/objects/post/objects/validate) it against the collection definition.

**Python**

```py
# Validate is currently not supported with the Weaviate Python client v4
```

**JavaScript/TypeScript**

```ts
// Validate is currently not supported with the Weaviate TypeScript client v3
```

**Go (v5)**

```go
err := client.Data().Validator().
  WithClassName("JeopardyQuestion").
  WithProperties(map[string]interface{}{
  	"question":                          "This vector DB is OSS and supports automatic property type inference on import",
  	"answer":                            "Weaviate",
  	"thisPropShouldNotEndUpInTheSchema": -1,
  }).
  WithID("12345678-1234-1234-1234-123456789012").
  Do(ctx)

assert.ErrorContains(t, err, "invalid object: no such prop with name 'thisPropShouldNotEndUpInTheSchema' found")
```

**Go (v6)**

```go
// Coming soon
```

**Java**

```java
  // Coming soon
```

**C#**

```csharp
    // Coming soon
```

## Multiple vector embeddings (named vectors)

Collections can have multiple [named vectors](https://docs.weaviate.io/weaviate/config-refs/collections#named-vectors).

The vectors in a collection can have their own configurations. Each vector space can set its own index, its own compression algorithm, and its own vectorizer. This means you can use different vectorization models, and apply different distance metrics, to the same object.

To work with named vectors, adjust your queries to specify a target vector for [vector search](https://docs.weaviate.io/weaviate/search/similarity#named-vectors) or [hybrid search](https://docs.weaviate.io/weaviate/search/hybrid#named-vectors) queries.

## Related pages

- [Connect to Weaviate](https://docs.weaviate.io/weaviate/connections)

- [How-to: (Batch) Import items](https://docs.weaviate.io/weaviate/manage-objects/import)

- [References: REST - /v1/objects](https://docs.weaviate.io/weaviate/api/rest#tag/objects)