---
title: "Sending data to the HTTP API endpoint"
canonical: "https://docs.devo.com/space/latest/94658823/Sending%20data%20to%20the%20HTTP%20API%20endpoint"
format: markdown
---
> Macro (toc)

## Overview

The recommended way to send events to Devo is by using Syslog. However, there are situations where HTTP ingestion may be preferred, such as when direct TCP connections are not feasible or when clients need to integrate with systems that only support HTTP.

Devo offers two HTTP endpoints or modes for event ingestion:

- Event mode - Designed to send **one** event per HTTP request.
- Stream mode - Designed to send **multiple** events per HTTP request.

> ⚠️ **Maximum size**
> ⚠️ 
> ⚠️ > Macro (excerpt-include)

## Create the token needed to authorize the endpoint

The OAuth token is a 32-character alphanumeric string that authorizes a connection to Devo. When this token is used when making HTTP requests to Devo, the connection is authorized and the request is carried out. To create the required token:

> Macro (rw-ui-steps-macro)
> 
> > Macro (rw-step)
> 
> Log in to your Devo domain and go to **Administration → Credentials** **→** **Authentication tokens**.
> 
> > Macro (rw-step)
> 
> Click **Create token**.
> 
> ![image](media://c4144171-7450-4b5f-9176-394c07107597)
> 
> > Macro (rw-step)
> 
> Enter a descriptive **Name **and choose the person that will use the token in the **Authorized user **field. This can be either yourself or a user in your domain.
> 
> > Macro (rw-step)
> 
> Select the destination **Target table/s **for the events. These are the tag or tags that will be used by Devo to classify the events. You can use wildcards to send the data to multiple tables. For example, to send the events to all tables that begin with "my.app", you can specify **my.app.****. See the [Authentication tokens](https://devodocs.atlassian.net/wiki/spaces/latest/pages/94763821) section to learn more about how to use wildcards when identifying target tables.
> 
> > ⚠️ Note that it is not possible to ingest data to tables that receive events in [CEF syslog format](https://devodocs.atlassian.net/wiki/spaces/latest/pages/94666383) using this method.
> 
> > Macro (rw-step)
> 
> In the **Type **field, choose **HTTP ingestion**.
> 
> > Macro (rw-step)
> 
> Optionally, check the **Expiration date **field if you want to enter an expiration date for the new token. Choose the required date in the calendar.
> 
> > Macro (rw-step)
> 
> Click **Create**. The token is generated and appears in the token list below.

## Configure the HTTP endpoint

Once the token has been generated, you can configure the endpoint. The URL to send the HTTP request follows this format:

```
<endpoint>/<mode>/<domain>/token!<token>/<host>/<tag>?<message>
```

Where each element in the URL is described below:

| **Element** | **Description** |
| --- | --- |
| `<endpoint>` | Get the endpoint URL from the list of HTTP [Event load balancers](https://devodocs.atlassian.net/wiki/spaces/latest/pages/94653692) in the Devo web application.<br>For example: `https://http-us3.devo.io:8433`<br>![image-20251202-014601.png](media://fded78f3-4258-48de-a9ff-b3594c1055ae) |
| `<mode>` | This can be one of the following:<br>- `event`* *- Use this mode to send single events. `GET` and `POST` methods are accepted. See some examples in the section below.
- `stream`* *- Use this mode to send multiple events. Only `POST` is accepted. Use the header `Content-Encoding: gzip` to send multiple compressed events in your request body. Check some examples in the section below. |
| `<domain>` | The name of the Devo domain where the events are being sent to. |
| `<token>` | The token you generated in Devo to authorize your connection. |
| `<host>` | Specify the required hostname. |
| `<tag>` | The Devo tag to be applied to the events. Learn more about tags in [About Devo tags](https://devodocs.atlassian.net/wiki/spaces/latest/pages/95126204). |
| `<message>` | The log to be sent. Note that this is only valid if you’re using the `event` mode, that is to say, you're sending a single event to Devo. In this case, the event is added to the query string.<br>In case of a `POST` request in `stream` mode, events should be added to the request body. See some examples of this in the section below. |

<span style="color: #222222">Here is an example of an endpoint URL:</span>

```
https://http-us.devo.io/event/myDomain/token!a5370g9e8f7d7edf9d/local1/my.app.http.js?this%20is%20a%20example%20of%20log
```

## Code samples

Here you can see a few examples of how token-based HTTP requests can be sent from an endpoint to a table (or tables) in a Devo domain. 

> Macro (toc)

### Sending a single event

> Macro (rw-ui-tabs-macro)
> 
> > Macro (rw-tab)
> 
> Send a single event in a single HTTP request using the URL query string to encode the event message. This method uses the HTTP GET method.
> 
> #### Anatomy of the request
> 
> ```
> GET <endpoint>/event/<domain>/token!<token>/<host>/<tag>?<message> HTTP/1.1
> Host: <host>
> ```
> 
> #### Examples
> 
> <u>JavaScript</u>
> 
> ```
> const https = require('https');
> 
> const URL_HOST = process.env.URL_HOST;
> const URL_PORT = process.env.URL_PORT || 443;
> const TOKEN = process.env.TOKEN;
> const DOMAIN = process.env.DOMAIN;
> const HOST = process.env.HOST;
> const TAG = process.env.TAG;
> const ACCEPT_UNAUTHORIZED = process.env.ACCEPT_UNAUTHORIZED !== undefined;
> 
> const message = 'This is Sparta!';
> const querystring = encodeURIComponent(message);
> const options = {
>   hostname: URL_HOST,
>   port: URL_PORT,
>   path: `/event/${DOMAIN}/token!${TOKEN}/${HOST}/${TAG}?${querystring}`,
>   method: 'GET',
>   headers: {
>     'Content-Type': 'text/plain',
>   },
>   rejectUnauthorized: !ACCEPT_UNAUTHORIZED
> };
> 
> const req = https.request(options, res => {
>   console.log(`statusCode: ${res.statusCode}`);
>   res.on('data', chunk => console.log(`Response: ${chunk}`));
> });
> req.on('error', err => console.error(err));
> req.end();
> ```
> 
> <u>Python</u>
> 
> ```
> import http.client
> import ssl
> import os
> import urllib
> 
> URL_HOST = os.environ.get("URL_HOST")
> URL_PORT = os.environ.get("URL_PORT", 443)
> TOKEN = os.environ.get("TOKEN", "TOKEN")
> DOMAIN = os.environ.get("DOMAIN","DOMAIN")
> HOST = os.environ.get("HOST","HOST")
> TAG = os.environ.get("TAG","TAG")
> ACCEPT_UNAUTHORIZED = os.environ.get("ACCEPT_UNAUTHORIZED")
> 
> context = (
>     ssl._create_unverified_context()
>     if ACCEPT_UNAUTHORIZED
>     else ssl.create_default_context()
> )
> conn = http.client.HTTPSConnection(URL_HOST, URL_PORT, context=context)
> 
> message = urllib.parse.quote("This is Sparta!")
> path = f"/event/{DOMAIN}/token!{TOKEN}/{HOST}/{TAG}?{message}"
> headers = {"Content-Type": "text/plain"}
> conn.request("GET", path, headers=headers)
> 
> response = conn.getresponse()
> print(response.status)
> print(response.read().decode())
> conn.close()
> ```
> 
> <u>Bash</u>
> 
> ```
> #!/usr/bin/env bash
> 
> if [[ -z "$URL_HOST" || -z "$TOKEN" || -z "$DOMAIN" || -z "$HOST" || -z "$TAG" ]]; then
>     echo "Please set all required environment variables: URL_HOST, TOKEN, DOMAIN, HOST, TAG"
>     exit 1
> fi
> URL_PORT="${URL_PORT:-443}"
> 
> MESSAGE="This is Sparta!"
> URL="https://$URL_HOST:$URL_PORT/event/$DOMAIN/token!$TOKEN/$HOST/$TAG?"
> curl -v -G --data-urlencode "$MESSAGE" "$URL"
> ```
> 
> > Macro (rw-tab)
> 
> Send a single event in a single HTTP request using the body to encode the event message. This method uses the HTTP POST method.
> 
> #### Anatomy of the request
> 
> ```
> POST <endpoint>/event/<domain>/token!<token>/<host>/<tag> HTTP/1.1
> Host: <host>
> Content-Length: <message length>
> 
> <message>
> ```
> 
> #### Examples
> 
> <u>JavaScript</u>
> 
> ```
> const https = require('https');
> 
> const URL_HOST = process.env.URL_HOST;
> const URL_PORT = process.env.URL_PORT || 443;
> const TOKEN = process.env.TOKEN;
> const DOMAIN = process.env.DOMAIN;
> const HOST = process.env.HOST;
> const TAG = process.env.TAG;
> const ACCEPT_UNAUTHORIZED = process.env.ACCEPT_UNAUTHORIZED !== undefined;
> 
> const options = {
>   hostname: URL_HOST,
>   port: URL_PORT,
>   path: `/event/${DOMAIN}/token!${TOKEN}/${HOST}/${TAG}?`,
>   method: 'POST',
>   headers: {
>     'Content-Type': 'text/plain',
>   },
>   rejectUnauthorized: !ACCEPT_UNAUTHORIZED
> };
> 
> const req = https.request(options, res => {
>   console.log(`statusCode: ${res.statusCode}`);
>   res.on('data', chunk => console.log(`Response: ${chunk}`));
> });
> req.on('error', err => console.error(err));
> 
> const message = 'This is Sparta!';
> req.end(message);
> ```
> 
> <u>Python</u>
> 
> ```
> import http.client
> import ssl
> import os
> 
> URL_HOST = os.environ.get("URL_HOST")
> URL_PORT = os.environ.get("URL_PORT", 443)
> TOKEN = os.environ.get("TOKEN")
> DOMAIN = os.environ.get("DOMAIN")
> HOST = os.environ.get("HOST")
> TAG = os.environ.get("TAG")
> ACCEPT_UNAUTHORIZED = os.environ.get("ACCEPT_UNAUTHORIZED")
> 
> context = (
>     ssl._create_unverified_context()
>     if ACCEPT_UNAUTHORIZED
>     else ssl.create_default_context()
> )
> conn = http.client.HTTPSConnection(URL_HOST, URL_PORT, context=context)
> 
> path = f"/event/{DOMAIN}/token!{TOKEN}/{HOST}/{TAG}"
> headers = {"Content-Type": "text/plain"}
> body = "This is Sparta!".encode("utf-8")
> conn.request("POST", path, body=body, headers=headers)
> 
> response = conn.getresponse()
> print(response.status)
> print(response.read().decode())
> conn.close()
> ```
> 
> <u>Bash</u>
> 
> ```
> #!/usr/bin/env bash
> 
> if [[ -z "$URL_HOST" || -z "$TOKEN" || -z "$DOMAIN" || -z "$HOST" || -z "$TAG" ]]; then
>     echo "Please set all required environment variables: URL_HOST, TOKEN, DOMAIN, HOST, TAG"
>     exit 1
> fi
> URL_PORT="${URL_PORT:-443}"
> 
> MESSAGE="This is Sparta!"
> URL="https://$URL_HOST:$URL_PORT/event/$DOMAIN/token!$TOKEN/$HOST/$TAG"
> curl -v --data "$MESSAGE" "$URL"
> ```

### Sending multiple events

The stream mode sends multiple events in a single HTTP request. The events must be encoded in the body of the HTTP request using `\n` as a separator between event messages.

> Macro (rw-ui-tabs-macro)
> 
> > Macro (rw-tab)
> 
> Send a batch of events in a single HTTP request. Recommended when the client knows in advance the number of events to send.
> 
> #### Anatomy of the request
> 
> ```
> POST <endpoint>/stream/<domain>/token!<token>/<host>/<tag> HTTP/1.1
> Host: <host>
> Content-Length: <body length>
> 
> <message 1>\n
> <message 2>\n
> ...
> <message n>\n
> ```
> 
> #### Examples
> 
> <u>JavaScript</u>
> 
> ```
> const https = require('https');
> 
> const URL_HOST = process.env.URL_HOST;
> const URL_PORT = process.env.URL_PORT || 443;
> const TOKEN = process.env.TOKEN;
> const DOMAIN = process.env.DOMAIN;
> const HOST = process.env.HOST;
> const TAG = process.env.TAG;
> const ACCEPT_UNAUTHORIZED = process.env.ACCEPT_UNAUTHORIZED !== undefined;
> 
> const options = {
>   hostname: URL_HOST,
>   port: URL_PORT,
>   path: `/stream/${DOMAIN}/token!${TOKEN}/${HOST}/${TAG}?`,
>   method: 'POST',
>   headers: {
>     'Content-Type': 'text/plain',
>   },
>   rejectUnauthorized: !ACCEPT_UNAUTHORIZED
> };
> 
> const req = https.request(options, res => {
>   console.log(`statusCode: ${res.statusCode}`);
>   res.on('data', chunk => console.log(`Response: ${chunk}`));
> });
> req.on('error', err => console.error(err));
> 
> const batch = createBatch('This is Sparta!', 10);
> req.end(batch);
> 
> function createBatch(message, n) {
>   return Array.from({length: n}, (_, i) => `${message} ${i + 1}`).join(`\n`);
> }
> ```
> 
> <u>Python</u>
> 
> ```
> import http.client
> import ssl
> import os
> 
> URL_HOST = os.environ.get("URL_HOST")
> URL_PORT = os.environ.get("URL_PORT", 443)
> TOKEN = os.environ.get("TOKEN")
> DOMAIN = os.environ.get("DOMAIN")
> HOST = os.environ.get("HOST")
> TAG = os.environ.get("TAG")
> ACCEPT_UNAUTHORIZED = os.environ.get("ACCEPT_UNAUTHORIZED")
> 
> def createBatch(message, n):
>     return '\n'.join([f"{message} {i}" for i in range(1, n + 1)])
> 
> context = (
>     ssl._create_unverified_context()
>     if ACCEPT_UNAUTHORIZED
>     else ssl.create_default_context()
> )
> conn = http.client.HTTPSConnection(URL_HOST, URL_PORT, context=context)
> 
> path = f"/stream/{DOMAIN}/token!{TOKEN}/{HOST}/{TAG}?"
> headers = {"Content-Type": "text/plain"}
> body = createBatch("This is Sparta!", 10).encode("utf-8")
> conn.request("POST", path, body=body, headers=headers)
> 
> response = conn.getresponse()
> print(response.status)
> print(response.read().decode())
> conn.close()
> ```
> 
> <u>Bash</u>
> 
> ```
> #!/usr/bin/env bash
> 
> if [[ -z "$URL_HOST" || -z "$TOKEN" || -z "$DOMAIN" || -z "$HOST" || -z "$TAG" ]]; then
>     echo "Please set all required environment variables: URL_HOST, TOKEN, DOMAIN, HOST, TAG"
>     exit 1
> fi
> URL_PORT="${URL_PORT:-443}"
> 
> create_batch() {
>     local message="$1"
>     local n="$2"
>     local batch=""
> 
>     for i in $(seq 1 $n)
>     do
>         batch+="\n$message $i"
>     done
> 
>     printf "${batch:2}"
> }
> 
> URL="https://$URL_HOST:$URL_PORT/stream/$DOMAIN/token!$TOKEN/$HOST/$TAG?"
> create_batch "This is Sparta!" 10 | curl -v --data-binary @- "$URL"
> ```
> 
> > Macro (rw-tab)
> 
> Sending a batch of events compressed with gzip in a single HTTP request can be useful for reducing the size of the data transmitted over the network (bandwidth), especially if the events are already compressed at the source.
> 
> #### Anatomy of the request
> 
> ```
> POST <endpoint>/stream/<domain>/token!<token>/<host>/<tag> HTTP/1.1
> Host: <host>
> Content-Encoding: gzip
> Content-Length: <body length>
> 
> <compressed body>
> ```
> 
> #### Examples
> 
> <u>JavaScript</u>
> 
> ```
> const https = require('https');
> const zlib = require('zlib');
> 
> const URL_HOST = process.env.URL_HOST;
> const URL_PORT = process.env.URL_PORT || 443;
> const TOKEN = process.env.TOKEN;
> const DOMAIN = process.env.DOMAIN;
> const HOST = process.env.HOST;
> const TAG = process.env.TAG;
> const ACCEPT_UNAUTHORIZED = process.env.ACCEPT_UNAUTHORIZED !== undefined;
> 
> const options = {
>   hostname: URL_HOST,
>   port: URL_PORT,
>   path: `/stream/${DOMAIN}/token!${TOKEN}/${HOST}/${TAG}?`,
>   method: 'POST',
>   headers: {
>     'Content-Type': 'text/plain',
>     'Content-Encoding': 'gzip'
>   },
>   rejectUnauthorized: !ACCEPT_UNAUTHORIZED
> };
> 
> const req = https.request(options, res => {
>   console.log(`statusCode: ${res.statusCode}`);
>   res.on('data', chunk => console.log(`Response: ${chunk}`));
> });
> req.on('error', err => console.error(err));
> 
> const batch = createBatch('This is Sparta!', 10);
> const payload = zlib.gzipSync(batch);
> req.end(payload);
> 
> function createBatch(message, n) {
>   return Array.from({length: n}, (_, i) => `${message} ${i + 1}`).join(`\n`);
> }
> ```
> 
> <u>Python</u>
> 
> ```
> import http.client
> import ssl
> import os
> import gzip
> 
> URL_HOST = os.environ.get("URL_HOST")
> URL_PORT = os.environ.get("URL_PORT", 443)
> TOKEN = os.environ.get("TOKEN")
> DOMAIN = os.environ.get("DOMAIN")
> HOST = os.environ.get("HOST")
> TAG = os.environ.get("TAG")
> ACCEPT_UNAUTHORIZED = os.environ.get("ACCEPT_UNAUTHORIZED")
> 
> def createBatch(message, n):
>     return '\n'.join([f"{message} {i}" for i in range(1, n + 1)])
> 
> context = (
>     ssl._create_unverified_context()
>     if ACCEPT_UNAUTHORIZED
>     else ssl.create_default_context()
> )
> conn = http.client.HTTPSConnection(URL_HOST, URL_PORT, context=context)
> 
> path = f"/stream/{DOMAIN}/token!{TOKEN}/{HOST}/{TAG}?"
> headers = {
>     "Content-Type": "text/plain",
>     "Content-Encoding": "gzip"
> }
> body = createBatch("This is Sparta!", 10).encode("utf-8")
> body = gzip.compress(body)
> conn.request("POST", path, body=body, headers=headers)
> 
> response = conn.getresponse()
> print(response.status)
> print(response.read().decode())
> conn.close()
> ```
> 
> <u>Bash</u>
> 
> ```
> #!/usr/bin/env bash
> 
> if [[ -z "$URL_HOST" || -z "$TOKEN" || -z "$DOMAIN" || -z "$HOST" || -z "$TAG" ]]; then
>     echo "Please set all required environment variables: URL_HOST, TOKEN, DOMAIN, HOST, TAG"
>     exit 1
> fi
> URL_PORT="${URL_PORT:-443}"
> 
> create_batch() {
>     local message="$1"
>     local n="$2"
>     local batch=""
> 
>     for i in $(seq 1 $n)
>     do
>         batch+="\n$message $i"
>     done
> 
>     printf "${batch:2}"
> }
> 
> URL="https://$URL_HOST:$URL_PORT/stream/$DOMAIN/token!$TOKEN/$HOST/$TAG?"
> create_batch "This is Sparta!" 10 \
> | gzip \
> | curl -v --data-binary @- --header "Content-Encoding: gzip" "$URL"
> 
> ```
> 
> > Macro (rw-tab)
> 
> Send a stream of events in a single HTTP request. Useful when the client does not know in advance the number of events to send.
> 
> This method uses [chunked transfer encoding](https://en.wikipedia.org/wiki/Chunked_transfer_encoding) to stream events using the body of the HTTP request.
> 
> #### Anatomy of the request
> 
> ```
> POST <endpoint>/stream/<domain>/token!<token>/<host>/<tag> HTTP/1.1
> Host: <host>
> Transfer-Encoding: chunked
> 
> <chunk 1 size>\r\n
> <chunk 1>\r\n
> <chunk 2 size>\r\n
> <chunk 2>\r\n
> ...
> <chunk n size>\r\n
> <chunk n>\r\n
> 0\r\n\r\n
> ```
> 
> #### Examples
> 
> <u>JavaScript</u>
> 
> ```
> const https = require('https');
> 
> const URL_HOST = process.env.URL_HOST;
> const URL_PORT = process.env.URL_PORT || 443;
> const TOKEN = process.env.TOKEN;
> const DOMAIN = process.env.DOMAIN;
> const HOST = process.env.HOST;
> const TAG = process.env.TAG;
> const ACCEPT_UNAUTHORIZED = process.env.ACCEPT_UNAUTHORIZED !== undefined;
> 
> const options = {
>   hostname: URL_HOST,
>   port: URL_PORT,
>   path: `/stream/${DOMAIN}/token!${TOKEN}/${HOST}/${TAG}?`,
>   method: 'POST',
>   headers: {
>     'Content-Type': 'text/plain',
>     'Transfer-Encoding': 'chunked'
>   },
>   rejectUnauthorized: !ACCEPT_UNAUTHORIZED
> };
> 
> const req = https.request(options, res => {
>   console.log(`statusCode: ${res.statusCode}`);
>   res.on('data', chunk => console.log(`Response: ${chunk}`));
> });
> req.on('error', err => console.error(err));
> 
> async function main() {
>   const stream = createStream('This is Sparta!', 10);
>   for await (const message of stream) {
>     req.write(message);
>   }
>   req.end();
> }
> main();
> 
> async function* createStream(message, n, delay = 1000) {
>   for (let i = 1; i <= n; i++) {
>     yield `${message} ${i}\n`;
>     await new Promise(resolve => setTimeout(resolve, delay));
>   }
> }
> ```
> 
> <u>Python</u>
> 
> ```
> import http.client
> import ssl
> import time
> import os
> 
> URL_HOST = os.environ.get("URL_HOST")
> URL_PORT = os.environ.get("URL_PORT", 443)
> TOKEN = os.environ.get("TOKEN")
> DOMAIN = os.environ.get("DOMAIN")
> HOST = os.environ.get("HOST")
> TAG = os.environ.get("TAG")
> ACCEPT_UNAUTHORIZED = os.environ.get("ACCEPT_UNAUTHORIZED")
> 
> def createChunk(message):
>     data = message.encode("utf-8")
>     size = format(len(data), 'x').encode("utf-8")
>     return b"%b\r\n%b\r\n" % (size, data)
> 
> def endChunk():
>     return b"0\r\n\r\n"
> 
> def createStream(message, n, delay=1000):
>     for i in range(1, n + 1):
>         yield f"{message} {i}\n"
>         time.sleep(delay / 1000)
> 
> context = (
>     ssl._create_unverified_context()
>     if ACCEPT_UNAUTHORIZED
>     else ssl.create_default_context()
> )
> conn = http.client.HTTPSConnection(URL_HOST, URL_PORT, context=context)
> 
> path = f"/stream/{DOMAIN}/token!{TOKEN}/{HOST}/{TAG}?"
> headers = {"Content-Type": "text/plain", "Transfer-Encoding": "chunked"}
> conn.request("POST", path, headers=headers)
> 
> for message in createStream("This is Sparta!", 10):
>     print(message)
>     conn.send(createChunk(message))
> conn.send(endChunk())
> 
> response = conn.getresponse()
> print(response.status)
> print(response.read().decode())
> conn.close()
> ```
> 
> <u>Bash</u>
> 
> ```
> #!/usr/bin/env bash
> 
> if [[ -z "$URL_HOST" || -z "$TOKEN" || -z "$DOMAIN" || -z "$HOST" || -z "$TAG" ]]; then
>     echo "Please set all required environment variables: URL_HOST, TOKEN, DOMAIN, HOST, TAG"
>     exit 1
> fi
> URL_PORT="${URL_PORT:-443}"
> 
> create_stream() {
>     local message="$1"
>     local n="$2"
> 
>     for i in $(seq 1 $n)
>     do
>         printf "$message $i\n"
>         sleep 1
>     done
> }
> 
> URL="https://$URL_HOST:$URL_PORT/stream/$DOMAIN/token!$TOKEN/$HOST/$TAG?"
> # It appears that curl buffers the chunks and sends them once all messages
> # are generated as a single chunk. This behavior likely occurs because
> # curl has an internal buffer, and when all messages are combined, they
> # do not exceed this buffer limit.
> create_stream "This is Sparta!" 10 \
> | curl -v --data-binary @- --header "Transfer-Encoding: chunked" "$URL"
> ```

## Response codes

Take into consideration the following points related to the response codes returned by the HTTP API:

- The HTTP API is designed as an asynchronous API that immediately returns a `2XX` status code upon receiving a request.
- The `2XX` status code of the response only indicates that the request has been received but not completed yet.
- The response is sent prior to any further processing, including token validation (authentication and authorization), or any other checks that may result in an invalid event submission.
- The specific `2xx` status code depends on the mode of the request. The `/event` mode returns a `204 No Content` status code while the `/stream mode` returns a `200 OK`
- The only way to verify that an event is properly stored is by querying it.
- This HTTP API operates similarly to job submissions commonly used in batch-processing scenarios.


#### Related articles

- [Security credentials](https://devodocs.atlassian.net/wiki/spaces/latest/pages/94763701)