REST - /v1/objects

List all data objects

Lists all data objects in reverse order of creation. The data will be returned as an array of objects

Method and URL

Without any restrictions (across classes, default limit):

GET /v1/objects

With optional query params:

GET /v1/objects?class={className}&limit={limit}&include={include}

Parameters

name	location	type
`limit`	URL Query Parameter (optional)	integer
`include`	URL Query Parameter (optional)	string
`class`	URL Query Parameter (optional)	string

Response fields

The response of a GET query of a data object will give you information about all objects (or a single object). Next to general information about the data objects, like schema information and property values, meta information will be shown depending on the include fields or additional properties of your request.

Response format

{
  "objects": [/* list of objects, see below */],
  "deprecations: null,
}

Object fields

field name	datatype	required `include` or `additional` field	description
`class`	string	none	the class name
`creationTimeUnix`	unix timestamp	none	the time stamp of creation of the data object
`id`	uuid	none	the uuid of the data object
`lastUpdateTimeUnix`	unix timestamp	none	the time stamp when the data object was last updated
`properties` > `{property_name}`	dataType	none	the name and value of an individual property
`properties` > `{cref_property_name}` > `classification` > `closestLosingDistance`	float	`classification`	The lowest distance of a neighbor in the losing group. Optional. If `k` equals the size of the winning group, there is no losing group.
`properties` > `{cref_property_name}` > `classification` > `closestOverallDistance`	float	`classification`	The lowest distance of any neighbor, regardless of whether they were in the winning or losing.
`properties` > `{cref_property_name}` > `classification` > `closestWinningDistance`	float	`classification`	Closest distance of a neighbor from the winning group.
`properties` > `{cref_property_name}` > `classification` > `losingCount`	integer	`classification`	Size of the losing group, can be 0 if the winning group size equals `k`.
`properties` > `{cref_property_name}` > `classification` > `meanLosingDistance`	float	`classification`	The mean distance of the losing group. It is a normalized distance (between 0 and 1), where 0 means equal and 1 would mean a perfect opposite.
`properties` > `{cref_property_name}` > `classification` > `meanWinningDistance`	float	`classification`	The mean distance of the winning group. It is a normalized distance (between 0 and 1), where 0 means equal and 1 would mean a perfect opposite.
`properties` > `{cref_property_name}` > `classification` > `overallCount`	integer	`classification`	Overall neighbors checked as part of the classification. In most cases this will equal `k`, but could be lower than `k` - for example if not enough data was present.
`properties` > `{cref_property_name}` > `classification` > `winningCount`	integer	`classification`	Size of the winning group, a number between 1 and `k`.
`vector`	list of floats	`vector`	the long vector of the location of the object in the 300 dimensional space
`classification` > `basedOn`	string	`classification`	the property name where the classification was based on
`classification` > `classifiedFields`	string	`classification`	the classified property
`classification` > `completed`	timestamp	`classification`	the time of classification completion
`classification` > `id`	uuid	`classification`	the classification id
`classification` > `scope`	list of strings	`classification`	the initial fields to classify
`featureProjection` > `vector`	list of floats	`featureProjection`	the 2D or 3D vector coordinates of the feature projection

Status codes and error cases

Cause	Description	Result
No objects present	No `?class` is provided. There are no objects present in the entire Weaviate instance.	`200 OK` - No error
Valid class, no objects present	`?class` is provided, class exists. There are no objects present for this class	`200 OK` - No error
Invalid class	`?class` is provided, class does not exist	`404 Not Found`
Validation	Otherwise invalid user request	`422 Unprocessable Entity`
Authorization	Not allowed to view resource	`403 Forbidden`
Server-Side error	Correct user input, but request failed for another reason	`500 Internal Server Error` - contains detailed error message

Example request

Python
JavaScript
Go
Java
Curl

import weaviate

client = weaviate.Client("http://localhost:8080")

all_objects = client.data_object.get(class_name="MyClass")
print(all_objects)

const weaviate = require('weaviate-client');

const client = weaviate.client({
  scheme: 'http',
  host: 'localhost:8080',
});

client
    .data
    .getter()
    .withClassName('MyClass')
    .withLimit(2)
    .do()
    .then(res => {
        console.log(res)
    })
    .catch(err => {
        console.error(err)
    });

package main

import (
    "context"
    "fmt"

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

func main() {
    cfg := weaviate.Config{
        Host:   "localhost:8080",
        Scheme: "http",
    }
    client := weaviate.New(cfg)

    data, err := client.Data().ObjectsGetter().
        WithClassName("MyClass").
        WithAdditional("classification").
        Do(context.Background())

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

package technology.semi.weaviate;

import java.util.List;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.WeaviateObject;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    Result<List<WeaviateObject>> result = client.data().objectsGetter()
      .withClassName("MyClass")
      .withAdditional("classification")
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

$ curl http://localhost:8080/v1/objects?limit=2&include=classification&class=MyClass

Create a data object

Create a new data object. The provided meta-data and schema values are validated.

Performance

💡 This endpoint is meant for individual object creations.

If you have a whole dataset that you plan on importing with Weaviate sending multiple single requests sequentially comes at a large cost:

Each sequential request would be handled by a single thread server-side while most of the server resources are idle. In addition, if you only send the second request once the first has been completed, you will wait for a lot of network overhead.
It's much more efficient to parallelize imports. This will minimize the connection overhead and use multiple threads server-side for indexing.
You do not have to do the parallelization yourself, you can use the /v1/batch endpoint for this. Even if you are sending batches from a single client thread, the objects within a batch will be handled by multiple server threads.
Import speeds, especially for large datasets, will drastically improve when using the batching endpoint.
Go to the /v1/batch endpoint.

Method and URL

POST /v1/objects

Note: The className is not specified through the URL, as it is part of the request body.

Parameters

The body of the data object for a new object takes the following fields:

name	type	required	description
`class`	string	yes	the class name as defined in the schema
`properties`	array	yes	an object with the property values of the new data object
`properties` > `{property_name}`	dataType	yes	the property and its value according to the set dataType
`id`	v4 UUID	no	the given id of the data object

Example request

Python
JavaScript
Go
Java
Curl

import weaviate

client = weaviate.Client("http://localhost:8080")

data_obj = {
    "name": "Jodi Kantor",
    "writesFor": [{
        "beacon": "weaviate://localhost/Article/f81bfe5e-16ba-4615-a516-46c2ae2e5a80"
    }]
}

data_uuid = client.data_object.create(
  data_obj,
  "Author",
  uuid="36ddd591-2dee-4e7e-a3cc-eb86d30a4303", # optional, if not provided, one is going to be generated
)

const weaviate = require('weaviate-client');

const client = weaviate.client({
  scheme: 'http',
  host: 'localhost:8080',
});

client.data
      .creator()
      .withClassName('Author')
      .withId('36ddd591-2dee-4e7e-a3cc-eb86d30a4303')
      .withProperties({
        'name': 'Jodi Kantor',
        'writesFor': [{
          'beacon': 'weaviate://localhost/f81bfe5e-16ba-4615-a516-46c2ae2e5a80'
        }]
      })
      .do()
      .then(res => {
          console.log(res)
      })
      .catch(err => {
          console.error(err)
      });

package main

import (
  "context"
  "fmt"

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

func main() {
  cfg := weaviate.Config{
    Host:   "localhost:8080",
    Scheme: "http",
  }
  client := weaviate.New(cfg)

  dataSchema := map[string]interface{}{
    "name": "Jodi Kantor",
    "writesFor": map[string]string{
      "beacon": "weaviate://localhost/f81bfe5e-16ba-4615-a516-46c2ae2e5a80",
    },
  }

  created, err := client.Data().Creator().
    WithClassName("Author").
    WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
    WithProperties(dataSchema).
    Do(context.Background())

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

package technology.semi.weaviate;

import java.util.HashMap;
import java.util.Map;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.WeaviateObject;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    Map<String, Object> dataSchema = new HashMap<>();
    dataSchema.put("name", "Jodi Kantor");
    dataSchema.put("writesFor", new HashMap() { {
      put("beacon", "weaviate://localhost/f81bfe5e-16ba-4615-a516-46c2ae2e5a80");
    } });

    Result<WeaviateObject> result = client.data().creator()
      .withClassName("Author")
      .withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
      .withProperties(dataSchema)
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

$ curl \
    -X POST \
    -H "Content-Type: application/json" \
    -d '{
      "class": "Author",
      "id": "36ddd591-2dee-4e7e-a3cc-eb86d30a4303",
      "properties": {
          "name": "Jodi Kantor",
          "writesFor": [{
            "beacon": "weaviate://localhost/f81bfe5e-16ba-4615-a516-46c2ae2e5a80"
          }]
      }
  }' \
    http://localhost:8080/v1/objects

Create an object with geoCoordinates

If you want to fill the value of a geoCoordinates property, you need to specify the latitude and longitude as decimal degrees in floats:

Python
JavaScript
Go
Java
Curl

import weaviate

client = weaviate.Client("http://localhost:8080")

data_obj = {
  "name": "Elsevier",
  "headquartersGeoLocation": {
    "latitude": 52.3932696,
    "longitude": 4.8374263
  }
}

data_uuid = client.data_object.create(
  data_obj,
  "Publication",
  uuid="df48b9f6-ba48-470c-bf6a-57657cb07390", # optional, if not provided, one is going to be generated
)

const weaviate = require('weaviate-client');

const client = weaviate.client({
  scheme: 'http',
  host: 'localhost:8080',
});

client.data
      .creator()
      .withClassName('Publication')
      .withId('df48b9f6-ba48-470c-bf6a-57657cb07390')
      .withProperties({
        'name': 'Elsevier',
        'headquartersGeoLocation': {
          'latitude': 52.3932696,
          'longitude': 4.8374263
        })
      .do()
      .then(res => {
          console.log(res)
      })
      .catch(err => {
          console.error(err)
      });

package main

import (
  "context"
  "fmt"

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

func main() {
  cfg := weaviate.Config{
    Host:   "localhost:8080",
    Scheme: "http",
  }
  client := weaviate.New(cfg)

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

package technology.semi.weaviate;

import java.util.HashMap;
import java.util.Map;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.WeaviateObject;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    Map<String, Object> dataSchema = new HashMap<>();
    dataSchema.put("name", "Elsevier");
    dataSchema.put("headquartersGeoLocation", new HashMap() { {
      put("latitude", 52.3932696f);
      put("longitude", 4.8374263f);
    } });

    Result<WeaviateObject> result = client.data().creator()
      .withClassName("Publication")
      .withID("df48b9f6-ba48-470c-bf6a-57657cb07390")
      .withProperties(dataSchema)
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

$ curl \
    -X POST \
    -H "Content-Type: application/json" \
    -d '{
      "class": "Publication",
      "id": "df48b9f6-ba48-470c-bf6a-57657cb07390",
      "properties": {
          "name": "Elsevier",
          "headquartersGeoLocation": {
            "latitude": 52.3932696,
            "longitude": 4.8374263
          }
      }
  }' \
    http://localhost:8080/v1/objects

Create a data object with a custom vector

When creating a data object, you can configure Weaviate to generate a vector with a vectorizer module, or you can provide the vector yourself. We sometimes refer to this as a "custom" vector.

You can provide a custom vector during object creation for either when:

you are not using a vectorizer for that class, or
you are using a vectorizer, but you wish to bypass it during the object creation stage. You can create a data object with a custom vector as follows:

Set the "vectorizer" in the relevant class in the data schema.
- If you are not using a vectorizer at all, configure the class accordingly. To do this, you can:
  - set the default vectorizer module to "none" (DEFAULT_VECTORIZER_MODULE="none"), or
  - set the "vectorizer" for the class to "none" ("vectorizer": "none") (note: the class vectorizer setting will override the DEFAULT_VECTORIZER_MODULE parameter).
- If you wish to bypass the vectorizer for object creation:
  - set the vectorizer to the same vectorizer with identical settings used to generate the custom vector
    Note: There is NO validation of this vector besides checking the vector length.
Then, attach the vector in a special "vector" field during object creation. For example, if adding a single object, you can:
Note: You can set custom vectors for batch imports as well as single object creation.

Python
JavaScript
Go
Java
Curl

import weaviate

client = weaviate.Client("http://localhost:8080")

data_obj = {
    "foo": "bar"
}

data_uuid = client.data_object.create(
  data_obj, 
  "YourClass", 
  uuid="36ddd591-2dee-4e7e-a3cc-eb86d30a0923", # optional, if not provided, one is going to be generated
  vector = [0.3, 0.2, 0.1, .... 0.9], # supported types are `list`, `numpy.ndarray`, `torch.Tensor` and `tf.Tensor`. Make sure the length matches with your Weaviate settings.
)

const weaviate = require('weaviate-client');

const client = weaviate.client({
  scheme: 'http',
  host: 'localhost:8080',
});

const vector = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9];

client.data
      .creator()
      .withClassName('Publication')
      .withId('df48b9f6-ba48-470c-bf6a-57657cb07390')
      .withProperties({
        'name': 'Elsevier',
        'headquartersGeoLocation': {
          'latitude': 52.3932696,
          'longitude': 4.8374263
        })
      .withVector(vector)
      .do()
      .then(res => {
          console.log(res)
      })
      .catch(err => {
          console.error(err)
      });

package main

import (
  "context"
  "fmt"

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

func main() {
  cfg := weaviate.Config{
    Host:   "localhost:8080",
    Scheme: "http",
  }
  client := weaviate.New(cfg)

  dataSchema := map[string]interface{}{
    "foo": "bar",
  }

  vector := []float32{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9}

  created, err := client.Data().Creator().
    WithClassName("YourClass").
    WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a0923").
    WithProperties(dataSchema).
    WithVector(vector).
    Do(context.Background())

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

package technology.semi.weaviate;

import java.util.HashMap;
import java.util.Map;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.WeaviateObject;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    Map<String, Object> dataSchema = new HashMap<>();
    dataSchema.put("name", "Jodi Kantor");
    dataSchema.put("writesFor", new HashMap() { {
      put("beacon", "weaviate://localhost/f81bfe5e-16ba-4615-a516-46c2ae2e5a80");
    } });

    Float[] vector = new Float[]{0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f};

    Result<WeaviateObject> result = client.data().creator()
      .withClassName("Author")
      .withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
      .withVector(vector)
      .withProperties(dataSchema)
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

$ curl \
    -X POST \
    -H "Content-Type: application/json" \
    -d '{
      "class": "YourClass",
      "vector": [0.3, 0.2, 0.1, .... 0.9],
      "properties": {
          "foo": "bar",
      }
  }' \
    http://localhost:8080/v1/objects

Learn here how you can search through custom vectors.

Get a data object

Collect an individual data object.

Method and URL

Available since v1.14 and preferred way:

GET /v1/objects/{className}/{id}

Available for backward compatibility and deprecated:

GET /v1/objects/{id}

Class Name in Object CRUD Operations

Prior to Weaviate v1.14 it was possible to manipulate objects using only their ID without specifying the class name. This way is still supported for backward compatibility, but is considered deprecated now. Avoid using the deprecated endpoints, as they will be removed with Weaviate v2.0.0.

The reason for the deprecation is that classes generally act like namespaces, therefore it is also feasible to have duplicate IDs across classes. However, when manipulating exactly one object by its ID (such as an update or delete), the ID may not be unique. It is thus recommended to always include the class name when manipulating objects.

Parameters

name	location	type
`{className}`	URL Path	string
`{id}`	URL Query param	uuid
`include`	URL Query param	string

Example request

See here the explanation of the response fields.

Python
JavaScript
Go
Java
Curl

import weaviate

client = weaviate.Client("http://localhost:8080")

data_object = client.data_object.get_by_id("36ddd591-2dee-4e7e-a3cc-eb86d30a4303", "MyClass")
print(data_object)

const weaviate = require('weaviate-client');

const client = weaviate.client({
  scheme: 'http',
  host: 'localhost:8080',
});

client
    .data
    .getterById()
    .withClassName('MyClass')
    .withId('36ddd591-2dee-4e7e-a3cc-eb86d30a4303')
    .do()
    .then(res => {
        console.log(res)
    })
    .catch(err => {
        console.error(err)
    });

package main

import (
    "context"
    "fmt"

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

func main() {
    cfg := weaviate.Config{
        Host:   "localhost:8080",
        Scheme: "http",
    }
    client := weaviate.New(cfg)

    data, err := client.Data().ObjectsGetter().
        WithClassName("MyClass").
        WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
        Do(context.Background())

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

package technology.semi.weaviate;

import java.util.List;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.WeaviateObject;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    Result<List<WeaviateObject>> result = client.data().objectsGetter()
      .withClassName("MyClass")
      .withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

$ curl http://localhost:8080/v1/objects/MyClass/36ddd591-2dee-4e7e-a3cc-eb86d30a4303

Example request for retrieving a data object with consistency_level=QUORUM

Python
JavaScript
Go
Java
Curl

import weaviate
from weaviate.data.replication import ConsistencyLevel

client = weaviate.Client("http://localhost:8080")

data_object = (
  client.data_object.get_by_id(
    uuid="36ddd591-2dee-4e7e-a3cc-eb86d30a4303",
    class_name="MyClass",
    consistency_level=ConsistencyLevel.QUORUM,
  )
)

# The parameter "consistency_level" can be one of ConsistencyLevel.ALL, ConsistencyLevel.QUORUM,
# or ConsistencyLevel.ONE. Determines how many replicas must acknowledge a request before it is
# considered successful.

print(data_object)

const weaviate = require('weaviate-client');

const client = weaviate.client({
  scheme: 'http',
  host: 'localhost:8080',
});

client
    .data
    .getterById()
    .withClassName('MyClass')
    .withId('36ddd591-2dee-4e7e-a3cc-eb86d30a4303')
    .withConsistencyLevel(weaviate.replication.ConsistencyLevel.QUORUM)
    .do()
    .then(res => {
        console.log(res)
    })
    .catch(err => {
        console.error(err)
    });

// The parameter "withConsistencyLevel" can be one of weaviate.replication.ConsistencyLevel.ALL, weaviate.replication.ConsistencyLevel.QUORUM, or weaviate.replication.ConsistencyLevel.ONE. Determines how many replicas must acknowledge a request before it is considered successful.
    

package main

import (
    "context"
    "fmt"

    "github.com/weaviate/weaviate-go-client/v4/weaviate/data/replication"
    "github.com/weaviate/weaviate-go-client/v4/weaviate"
)

func main() {
    cfg := weaviate.Config{
        Host:   "localhost:8080",
        Scheme: "http",
    }
    client := weaviate.New(cfg)

    data, err := client.Data().ObjectsGetter().
        WithClassName("MyClass").
        WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
        WithConsistencyLevel(replication.ConsistencyLevel.QUORUM).
        Do(context.Background())

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

// The parameter "WithConsistencyLevel" can be one of weaviate.replication.ConsistencyLevel.ALL, weaviate.replication.ConsistencyLevel.QUORUM, or weaviate.replication.ConsistencyLevel.ONE. Determines how many replicas must acknowledge a request before it is considered successful.

package technology.semi.weaviate;

import java.util.List;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.WeaviateObject;
import technology.semi.weaviate.client.v1.data.replication.model.ConsistencyLevel;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    Result<List<WeaviateObject>> result = client.data().objectsGetter()
      .withClassName("MyClass")
      .withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
      .withConsistencyLevel(ConsistencyLevel.QUORUM)
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

// The parameter "withConsistencyLevel" can be one of ConsistencyLevel.ALL, ConsistencyLevel.QUORUM, or ConsistencyLevel.ONE. Determines how many replicas must acknowledge a request before it is considered successful.

$ curl http://localhost:8080/v1/objects/MyClass/36ddd591-2dee-4e7e-a3cc-eb86d30a4303?consistency_level=QUORUM

# The parameter "consistency_level" can be one of ALL, QUORUM, or ONE. Determines how many replicas must acknowledge a request before it is considered successful.
# curl /v1/objects/{className}/{id}?consistency_level=ALL

Check if a data object exists without retrieving it

This endpoint can be used to check if a data object exists without retrieving it. Internally it skips reading the object from disk (other than checking if it is present), thus not using resources on marshalling, parsing, etc. Additionally the resulting HTTP request has no body, the existence of an object is indicated solely by the status code (204 when the object exists, 404 when it doesn't).

Method and URL

Available since v1.14 and preferred way:

HEAD /v1/objects/{className}/{id}

Available for backward compatibility and deprecated:

HEAD /v1/objects/{id}

Class Name in Object CRUD Operations

Parameters

name	location	type
`{className}`	URL Path	string
`{id}`	URL	uuid

Example request

Python
JavaScript
Go
Java
Curl

import weaviate

client = weaviate.Client("http://localhost:8080")

exists = client.data_object.exists("36ddd591-2dee-4e7e-a3cc-eb86d30a4303", "MyClass")
print(exists) 

const weaviate = require('weaviate-client');

const client = weaviate.client({
  scheme: 'http',
  host: 'localhost:8080',
});

client.data
  .checker()
  .withClassName('MyClass')
  .withId('df48b9f6-ba48-470c-bf6a-57657cb07390')
  .do()
  .then((exists) => {
    console.log(exists)
  })
  .catch(err =>
    console.error(err)
  );

package main

import (
  "context"
  "fmt"

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

func main() {
  cfg := weaviate.Config{
    Host:   "localhost:8080",
    Scheme: "http",
  }
  client := weaviate.New(cfg)

  exists, err := client.Data().Checker().
    WithClassName("MyClass").
    WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a0923").
    Do(context.Background())

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

package technology.semi.weaviate;

import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    Result<Boolean> result = client.data().checker()
      .withClassName("MyClass")
      .withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

$ curl -I http://localhost:8080/v1/objects/MyClass/f3e20a86-0b44-4558-a336-bd137d866387 

Update a data object

Update an individual data object based on its uuid.

Method and URL

In the RESTful API, both PUT and PATCH methods are accepted. PUT replaces all property values of the data object, while PATCH only overwrites the given properties.

Available since v1.14 and preferred way:

PUT /v1/objects/{className}/{id}
PATCH /v1/objects/{className}/{id}

Available for backward compatibility and deprecated:

PUT /v1/objects/{id}
PATCH /v1/objects/{id}

Class Name in Object CRUD Operations

Parameters

name	location	type
`{className}`	URL Path	string
`{id}`	URL	uuid

The body of the data object for a replacing (some) properties of a object takes the following fields:

name	type	required	description
`class`	string	yes	the class name as defined in the schema
`properties`	array	yes	an object with the property values of the new data object
`properties` > `{property_name}`	dataType	yes	the property and its value according to the set dataType

Example request

Python
JavaScript
Go
Java
Curl

import weaviate

client = weaviate.Client("http://localhost:8080")

updated_schema = {
    "name": "J. Kantor"
}

# Update only the properties in variable "updated_schema"
client.data_object.update(
    updated_schema,
    "Author",
    "36ddd591-2dee-4e7e-a3cc-eb86d30a4303"
)

# Replaces the whole data object with the "updated_schema"
client.data_object.replace(
    updated_schema,
    "Author",
    "36ddd591-2dee-4e7e-a3cc-eb86d30a4303"
)

const weaviate = require('weaviate-client');

const client = weaviate.client({
  scheme: 'http',
  host: 'localhost:8080',
});

var className = 'Author';
var id = '36ddd591-2dee-4e7e-a3cc-eb86d30a4303';

client.data
    .getterById()
    .withClassName(className)
    .withId(id)
    .do()
    .then(res => {
        // alter the schema
        const schema = res.schema;
        schema.name = 'J. Kantor';
        return client.data
            .updater()
            .withId(id)
            .withClassName(thingClassName)
            .withProperties(schema)
            .do();
        })
    .then(res => {
        console.log(res)
    })
    .catch(err => {
        console.error(err)
    });

package main

import (
    "context"

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

func main() {
    cfg := weaviate.Config{
        Host:   "localhost:8080",
        Scheme: "http",
    }
    client := weaviate.New(cfg)

    dataSchema := map[string]interface{}{
        "name": "J. Kantor",
    }

    err := client.Data().Updater().
        WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
        WithClassName("Author").
        WithProperties(dataSchema).
        Do(context.Background())

    if err != nil {
        panic(err)
    }
}

package technology.semi.weaviate;

import java.util.HashMap;
import java.util.Map;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    Map<String, Object> properties = new HashMap<>();
    properties.put("name", "J. Kantor");

    Result<Boolean> result = client.data().updater()
      .withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
      .withClassName("Author")
      .withProperties(properties)
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

$ curl \
    -X PATCH \
    -H "Content-Type: application/json" \
    -d '{
      "class": "Author",
      "id": "36ddd591-2dee-4e7e-a3cc-eb86d30a4303",
      "properties": {
          "name": "J. Kantor"
      }
  }' \
    http://localhost:8080/v1/objects/Author/36ddd591-2dee-4e7e-a3cc-eb86d30a4303

If the update was successful, no content will be returned.

Delete a data object

Delete an individual data object from Weaviate.

Method and URL

Available since v1.14 and preferred way:

DELETE /v1/objects/{className}/{id}

Available for backward compatibility and deprecated:

DELETE /v1/objects/{id}

Class Name in Object CRUD Operations

Parameters

name	location	type
`{className}`	URL Path	string
`{id}`	URL	uuid

Example request

Python
JavaScript
Go
Java
Curl

import weaviate

client = weaviate.Client("http://localhost:8080")

client.data_object.delete("36ddd591-2dee-4e7e-a3cc-eb86d30a4303", "MyClass")

const weaviate = require('weaviate-client');

const client = weaviate.client({
  scheme: 'http',
  host: 'localhost:8080',
});

client.data
      .deleter()
      .withClassName('MyClass')
      .withId('36ddd591-2dee-4e7e-a3cc-eb86d30a4303')
      .do()
      .then(res => {
          console.log(res)
      })
      .catch(err => {
          console.error(err)
      });

package main

import (
  "context"

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

func main() {
  cfg := weaviate.Config{
    Host:   "localhost:8080",
    Scheme: "http",
  }
  client := weaviate.New(cfg)

  err := client.Data().Deleter().
    WithClassName("MyClass").
    WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
    Do(context.Background())

  if err != nil {
    panic(err)
  }
}

package technology.semi.weaviate;

import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    Result<Boolean> result = client.data().deleter()
      .withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
      .withClassName("MyClass")
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

$ curl -X DELETE http://localhost:8080/v1/objects/MyClass/36ddd591-2dee-4e7e-a3cc-eb86d30a4303

If the deletion was successful, no content will be returned.

Validate a data object

You can validate a data object's schema and meta data.

Method and URL

POST /v1/objects/validate

Note: As with creating an object, the className is not specified through the URL, as it is part of the request body.

Parameters

The body of the data object for a new data object is an object taking the following field:

name	type	required	description
`class`	string	yes	the class name as defined in the schema
`properties`	array	yes	an object with the property values of the new data object
`properties` > `{property_name}`	dataType	yes	the property and its value according to the set dataType
`id`	v4 uuid	no^*	The id of the data object. ^*An ID is required by the clients.

Example request

Python
JavaScript
Go
Java
Curl

import weaviate

client = weaviate.Client("http://localhost:8080")

schema = {"name": "New York Times"}

valid_thing = client.data_object.validate(
  schema,
  "Publication",
  "f81bfe5e-16ba-4615-a516-46c2ae2e5a80"
)
print(valid_thing)

const weaviate = require('weaviate-client');

const client = weaviate.client({
  scheme: 'http',
  host: 'localhost:8080',
});

var schema = {'name': 'New York Times'};

client.data
      .validator()
      .withId('f81bfe5e-16ba-4615-a516-46c2ae2e5a80')
      .withClassName('Publication')
      .withProperties(schema)
      .do()
      .then(res => {
        console.log(res)
      })
      .catch(err => {
        console.error(err)
      });

package main

import (
  "context"

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

func main() {
  cfg := weaviate.Config{
    Host:   "localhost:8080",
    Scheme: "http",
  }
  client := weaviate.New(cfg)

  dataSchema := map[string]interface{}{
    "name": "New York Times",
  }

  err := client.Data().Validator().
    WithID("f81bfe5e-16ba-4615-a516-46c2ae2e5a80").
    WithClassName("Publication").
    WithProperties(dataSchema).
    Do(context.Background())

  if err != nil {
    panic(err)
  }
}

package technology.semi.weaviate;

import java.util.HashMap;
import java.util.Map;
import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    Map<String, Object> dataSchema = new HashMap<>();
    dataSchema.put("name", "New York Times");

    Result<Boolean> result = client.data().validator()
      .withID("f81bfe5e-16ba-4615-a516-46c2ae2e5a80")
      .withClassName("Publication")
      .withProperties(dataSchema)
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

$ curl \
    -X POST \
    -H "Content-Type: application/json" \
    -d '{
        "class": "Publication",
        "id": "f81bfe5e-16ba-4615-a516-46c2ae2e5a80",
        "properties": {
            "name": "New York Times"
        }
    }' \
    http://localhost:8080/v1/objects/validate

If the schema of the object is valid, this request should return True/true in case of the clients and nothing with a plain RESTful request.

Cross-references

Add a cross reference

Method and URL

Available since v1.14 and preferred way:

POST /v1/objects/{className}/{id}/references/{property_name}

Available for backward compatibility and deprecated:

POST /v1/objects/{id}/references/{property_name}

Class Name in Object CRUD Operations

Parameters

name	location	type
`{className}`	URL Path	string
`{id}`	URL	uuid
`{property_name}`	URL	yes

The body of the data object for a new data object is an object taking the following field:

name	type	required	description
`beacon`	Weaviate Beacon	yes	the beacon URL of the reference, in the format of `weaviate://localhost/<ClassName>/<id>`

Note: In the beacon format, you need to always use localhost as the host, rather than the actual hostname. localhost refers to the fact that the beacon's target is on the same Weaviate instance, as opposed to a foreign instance.

Note: For backward compatibility, you can omit the class name in the beacon format and specify it as weaviate://localhost/<id>. This is, however, considered deprecated and will be removed with a future release, as duplicate IDs across classes could mean that this beacon is not uniquely identifiable.

Example request

Python
JavaScript
Go
Java
Curl

import weaviate
# weaviate.__version__ >= 3.7.0

client = weaviate.Client("http://localhost:8080")

client.data_object.reference.add(
  "36ddd591-2dee-4e7e-a3cc-eb86d30a4303",
  "wroteArticles",
  "6bb06a43-e7f0-393e-9ecf-3c0f4e129064",
  from_class_name="SourceClass",
  to_class_name="TargetClass",
)

const weaviate = require('weaviate-client');

const client = weaviate.client({
  scheme: 'http',
  host: 'localhost:8080',
});

client.data
      .referenceCreator()
      .withClassName('SourceClass')
      .withId('36ddd591-2dee-4e7e-a3cc-eb86d30a4303')
      .withReferenceProperty('wroteArticles')
      .withReference(
        client.data
          .referencePayloadBuilder()
          .withClassName('TargetClass')
          .withId('6bb06a43-e7f0-393e-9ecf-3c0f4e129064')
          .payload(),
      )
      .do()
      .then(res => {
          console.log(res)
      })
      .catch(err => {
          console.error(err)
      });

package main

import (
  "context"

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

func main() {
  cfg := weaviate.Config{
    Host:   "localhost:8080",
    Scheme: "http",
  }
  client := weaviate.New(cfg)

  reference := client.Data().ReferencePayloadBuilder().
    WithClassName("TargetClass").
    WithID("6bb06a43-e7f0-393e-9ecf-3c0f4e129064").Payload()

  err := client.Data().ReferenceCreator().
    WithClassName("SourceClass").
    WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
    WithReferenceProperty("wroteArticles").
    WithReference(reference).
    Do(context.Background())

  if err != nil {
    panic(err)
  }
}

package technology.semi.weaviate;

import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.SingleRef;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    SingleRef reference = client.data().referencePayloadBuilder()
      .withClassName("TargetClass")
      .withID("6bb06a43-e7f0-393e-9ecf-3c0f4e129064")
      .payload();

    Result<Boolean> result = client.data().referenceCreator()
      .withClassName("SourceClass")
      .withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
      .withReferenceProperty("wroteArticles")
      .withReference(reference)
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

$ curl \
    -X POST \
    -H "Content-Type: application/json" \
    -d '{
      "beacon": "weaviate://localhost/TargetClass/6bb06a43-e7f0-393e-9ecf-3c0f4e129064"
      }
  }' \
    http://localhost:8080/v1/objects/SourceClass/36ddd591-2dee-4e7e-a3cc-eb86d30a4303/references/wroteArticles

If the addition was successful, no content will be returned.

Update a cross reference

A PUT request updates all references of a property of a data object.

Method and URL

Available since v1.14 and preferred way:

PUT /v1/objects/{className}/{id}/references/{property_name}

Available for backward compatibility and deprecated:

PUT /v1/objects/{id}/references/{property_name}

Class Name in Object CRUD Operations

Parameters

name	location	type
`{className}`	URL Path	string
`{id}`	URL	uuid
`{property_name}`	URL	yes

The body of the data object for a new data object is a list of beacons:

name	type	required	description
`beacon`	Weaviate Beacon	yes	the beacon URL of the reference, in the format of `weaviate://localhost/<ClassName>/<id>`

Example request

Python
JavaScript
Go
Java
Curl

import weaviate

client = weaviate.Client("http://localhost:8080")

client.data_object.reference.update(
  "36ddd591-2dee-4e7e-a3cc-eb86d30a4303",
  "wroteArticles",
  ["6bb06a43-e7f0-393e-9ecf-3c0f4e129064", "b72912b9-e5d7-304e-a654-66dc63c55b32"]
  from_class_name="SourceClass",
  to_class_name="TargetClass"
)

const weaviate = require('weaviate-client');

const client = weaviate.client({
  scheme: 'http',
  host: 'localhost:8080',
});

client.data
      .referenceReplacer()
      .withClassName('SourceClass')
      .withId('36ddd591-2dee-4e7e-a3cc-eb86d30a4303')
      .withReferenceProperty('wroteArticles')
      .withReferences([
        client.data
          .referencePayloadBuilder()
          .withClassName('TargetClass')
          .withId('6bb06a43-e7f0-393e-9ecf-3c0f4e129064')
          .payload(),
        client.data
          .referencePayloadBuilder()
          .withClassName('TargetClass')
          .withId('b72912b9-e5d7-304e-a654-66dc63c55b32')
          .payload(),
      ])
      .do()
      .then(res => {
          console.log(res)
      })
      .catch(err => {
          console.error(err)
      });

package main

import (
  "context"

  "github.com/weaviate/weaviate-go-client/v4/weaviate"
  "github.com/weaviate/weaviate/entities/models"
)

func main() {
  cfg := weaviate.Config{
    Host:   "localhost:8080",
    Scheme: "http",
  }
  client := weaviate.New(cfg)

  references := &models.MultipleRef{
    client.Data().ReferencePayloadBuilder().
      WithVector(vector).
      WithClassName("TargetClass").
      WithID("6bb06a43-e7f0-393e-9ecf-3c0f4e129064").
      Payload(),
    client.Data().ReferencePayloadBuilder().
      WithClassName("TargetClass").
      WithID("b72912b9-e5d7-304e-a654-66dc63c55b32").
      Payload(),
  }

  err := client.Data().ReferenceReplacer().
    WithClassName("SourceClass").
    WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
    WithReferenceProperty("wroteArticles").
    WithReferences(references).
    Do(context.Background())

  if err != nil {
    panic(err)
  }
}

package technology.semi.weaviate;

import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.SingleRef;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    SingleRef[] references = new SingleRef[]{
      client.data().referencePayloadBuilder()
        .withClassName("TargetClass")
        .withID("6bb06a43-e7f0-393e-9ecf-3c0f4e129064")
        .payload(),
      client.data().referencePayloadBuilder()
        .withClassName("TargetClass")
        .withID("b72912b9-e5d7-304e-a654-66dc63c55b32")
        .payload()
    };

    Result<Boolean> result = client.data().referenceReplacer()
      .withClassName("SourceClass")
      .withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
      .withReferenceProperty("wroteArticles")
      .withReferences(references)
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

curl \
    -X PUT \
    -H "Content-Type: application/json" \
    -d '[{
        "beacon": "weaviate://localhost/TargetClass/6bb06a43-e7f0-393e-9ecf-3c0f4e129064"
      }, {
        "beacon": "weaviate://localhost/TargetClass/c707d9bc-840f-3997-a09a-da6dba7d0e87"
      }]
  }' \
    http://localhost:8080/v1/objects/SourceClass/36ddd591-2dee-4e7e-a3cc-eb86d30a4303/references/wroteArticles

If the addition was successful, no content will be returned.

Delete a cross reference

Delete the single reference that is given in the body from the list of references that this property of a data object has.

Method and URL

Available since v1.14 and preferred way:

DELETE /v1/objects/{className}/{id}/references/{property_name}

Available for backward compatibility and deprecated:

DELETE /v1/objects/{id}/references/{property_name}

Class Name in Object CRUD Operations

Parameters

name	location	type
`{id}`	URL	uuid
`{property_name}`	URL	yes

The body of the data object for a new data object is a list of beacons:

name	type	required	description
`beacon`	Weaviate Beacon	yes	the beacon URL of the reference, in the format of `weaviate://localhost/<ClassName>/<id>`

Note: For backward compatibility, beacons generally support an older, deprecated format without the class name, as well. This means you might find beacons with the old, deprecated format, as well as beacons with the new format in the same Weaviate instance. When deleting a reference, the beacon specified has to match the beacon to be deleted exactly. In other words, if a beacon is present using the old format (without class id) you also need to specify it the same way.

Example request

Python
JavaScript
Go
Java
Curl

import weaviate

client = weaviate.Client("http://localhost:8080")

client.data_object.reference.delete(
  "36ddd591-2dee-4e7e-a3cc-eb86d30a4303",
  "wroteArticles",
  "6bb06a43-e7f0-393e-9ecf-3c0f4e129064"
  from_class_name="SourceClass",
  to_class_name="TargetClass"
)

const weaviate = require('weaviate-client');

const client = weaviate.client({
  scheme: 'http',
  host: 'localhost:8080',
});

client.data
      .referenceDeleter()
      .withClassName('SourceClass')
      .withId('36ddd591-2dee-4e7e-a3cc-eb86d30a4303')
      .withReferenceProperty('wroteArticles')
      .withReference(
        client.data
          .referencePayloadBuilder()
          .withClassName('TargetClass')
          .withId('6bb06a43-e7f0-393e-9ecf-3c0f4e129064')
          .payload(),
      )
      .do()
      .then(res => {
          console.log(res)
      })
      .catch(err => {
          console.error(err)
      });

package main

import (
    "context"

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

func main() {
    cfg := weaviate.Config{
        Host:   "localhost:8080",
        Scheme: "http",
    }
    client := weaviate.New(cfg)

    reference := client.Data().ReferencePayloadBuilder().
      WithClassName("TargetClass").
      WithID("6bb06a43-e7f0-393e-9ecf-3c0f4e129064").Payload()

    err := client.Data().ReferenceDeleter().
      WithClassName("SourceClass").
      WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
      WithReferenceProperty("wroteArticles").
      WithReference(reference).
      Do(context.Background())

    if err != nil {
        panic(err)
    }
}

package technology.semi.weaviate;

import technology.semi.weaviate.client.Config;
import technology.semi.weaviate.client.WeaviateClient;
import technology.semi.weaviate.client.base.Result;
import technology.semi.weaviate.client.v1.data.model.SingleRef;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    SingleRef reference = client.data().referencePayloadBuilder()
      .withClassName("TargetClass")
      .withID("6bb06a43-e7f0-393e-9ecf-3c0f4e129064")
      .payload();

    Result<Boolean> result = client.data().referenceDeleter()
      .withClassName("SourceClass")
      .withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
      .withReferenceProperty("wroteArticles")
      .withReference(reference)
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

curl \
    -X DELETE \
    -H "Content-Type: application/json" \
    -d '{
        "beacon": "weaviate://localhost/TargetClass/6bb06a43-e7f0-393e-9ecf-3c0f4e129064"
    }
    }' \
    http://localhost:8080/v1/objects/SourceClass/36ddd591-2dee-4e7e-a3cc-eb86d30a4303/references/wroteArticles

If the addition was successful, no content will be returned.

List all data objects​

Method and URL​

Parameters​

Response fields​

Response format​

Object fields​

Status codes and error cases​

Example request​

Create a data object​

Performance​

Method and URL​

Parameters​

Example request​

Create an object with geoCoordinates​

Create a data object with a custom vector​

Get a data object​

Method and URL​

Parameters​

Example request​

Example request for retrieving a data object with consistency_level=QUORUM​

Check if a data object exists without retrieving it​

Method and URL​

Parameters​

Example request​

Update a data object​

Method and URL​

Parameters​

Example request​

Delete a data object​

Method and URL​

Parameters​

Example request​

Validate a data object​

Method and URL​

Parameters​

Example request​

Cross-references​

Add a cross reference​

Method and URL​

Parameters​

Example request​

Update a cross reference​

Method and URL​

Parameters​

Example request​

Delete a cross reference​

Method and URL​

Parameters​

Example request​

List all data objects

Method and URL

Parameters

Response fields

Response format

Object fields

Status codes and error cases

Example request

Create a data object

Performance

Method and URL

Parameters

Example request

Create an object with geoCoordinates

Create a data object with a custom vector

Get a data object

Method and URL

Parameters

Example request

Example request for retrieving a data object with consistency_level=QUORUM

Check if a data object exists without retrieving it

Method and URL

Parameters

Example request

Update a data object

Method and URL

Parameters

Example request

Delete a data object

Method and URL

Parameters

Example request

Validate a data object

Method and URL

Parameters

Example request

Cross-references

Add a cross reference

Method and URL

Parameters

Example request

Update a cross reference

Method and URL

Parameters

Example request

Delete a cross reference

Method and URL

Parameters

Example request