# Methods for sending data





The easiest way to send your first event data to Axiom is with a direct HTTP request using a tool like `cURL`.

```shell wrap
curl -X 'POST' 'https://AXIOM_DOMAIN/v1/ingest/DATASET_NAME' \
    -H 'Authorization: Bearer API_TOKEN' \
    -H 'Content-Type: application/x-ndjson' \
    -d '{ "http": { "request": { "method": "GET", "duration_ms": 231 }, "response": { "body": { "size": 3012 } } }, "url": { "path": "/download" } }'
```

<Info>
  <ReplaceDomain />

  <ReplaceDatasetToken />
</Info>

To send events continuously, Axiom supports a wide range of standard tools, libraries, and platform integrations.

## Popular methods [#popular-methods]

| Method                                    | Description                                                                                                         |
| :---------------------------------------- | :------------------------------------------------------------------------------------------------------------------ |
| [Rest API](/restapi/introduction)         | Direct HTTP API for sending logs and events                                                                         |
| [OpenTelemetry](/send-data/opentelemetry) | Industry-standard observability framework                                                                           |
| [Vector](/send-data/vector)               | High-performance observability data pipeline                                                                        |
| [Cribl](/send-data/cribl)                 | Route and transform data with Cribl Stream. For OCSF security data, see [Send OCSF data](/use-cases/ocsf/send-data) |
| [Fluent Bit](/send-data/fluent-bit)       | Fast and lightweight log processor                                                                                  |
| [Fluentd](/send-data/fluentd)             | Open source data collector with plugin ecosystem                                                                    |
| [JavaScript](/guides/javascript)          | Browser and Node.js logging                                                                                         |

## Other methods [#other-methods]

| Method                                                         | Description                                                               |
| :------------------------------------------------------------- | :------------------------------------------------------------------------ |
| [.NET](/guides/send-logs-from-dotnet)                          | Send logs from .NET applications                                          |
| [Apache Log4j](/guides/send-logs-from-apache-log4j)            | Java logging with Log4j integration                                       |
| [Apex](/guides/apex)                                           | Structured logging for Go                                                 |
| [Cloudflare Workers](/guides/opentelemetry-cloudflare-workers) | Edge computing with Workers and OpenTelemetry                             |
| [Convex](/send-data/convex)                                    | Stream data from Convex applications                                      |
| [Elastic Beats](/send-data/elastic-beats)                      | Lightweight data shippers from Elastic                                    |
| [Elasticsearch Bulk API](/send-data/elasticsearch-bulk-api)    | Compatible endpoint for Elasticsearch clients                             |
| [Elixir](/guides/send-logs-from-elixir)                        | Send logs from Elixir apps with a custom Logger handler                   |
| [Erlang](/guides/send-logs-from-erlang)                        | Send logs from Erlang/OTP apps with a custom logger handler               |
| [Flutter](/guides/flutter)                                     | Send structured logs from Flutter apps                                    |
| [Go](/guides/go)                                               | Native Go logging integration                                             |
| [Heroku Log Drains](/send-data/heroku-log-drains)              | Stream logs directly from Heroku apps                                     |
| [Honeycomb](/endpoints/honeycomb)                              | Compatible endpoint for Honeycomb clients                                 |
| [Kubernetes](/send-data/kubernetes)                            | Collect logs and metrics from K8s clusters                                |
| [Laravel](/guides/send-logs-from-laravel)                      | PHP Laravel framework integration                                         |
| [Logrus](/guides/logrus)                                       | Structured logging for Go with Logrus                                     |
| [Logstash](/send-data/logstash)                                | Server-side data processing pipeline                                      |
| [Loki](/endpoints/loki)                                        | Compatible endpoint for Grafana Loki clients                              |
| [Loki Multiplexer](/send-data/loki-multiplexer)                | Forward Loki data to multiple destinations                                |
| [Next.js](/send-data/nextjs)                                   | Full-stack React framework logging                                        |
| [PgBouncer](/send-data/pgbouncer)                              | PgBouncer metrics via pgbouncer\_exporter and the OpenTelemetry Collector |
| [Pino](/guides/pino)                                           | Fast Node.js logger integration                                           |
| [Python](/guides/python)                                       | Python logging with standard library                                      |
| [React](/send-data/react)                                      | Client-side React app logging                                             |
| [Render](/send-data/render)                                    | Stream logs from Render.com services                                      |
| [Ruby on Rails](/guides/send-logs-from-ruby-on-rails)          | Rails app logging                                                         |
| [Rust](/guides/rust)                                           | High-performance Rust logging                                             |
| [Secure Syslog](/send-data/secure-syslog)                      | TLS-encrypted syslog forwarding                                           |
| [Serverless](/send-data/serverless)                            | Best practices for serverless environments                                |
| [Splunk](/endpoints/splunk)                                    | Compatible endpoint for Splunk forwarders                                 |
| [Splunk HEC](/send-data/splunk-hec)                            | HTTP Event Collector compatible API on your edge deployment               |
| [StatsD](/send-data/statsd)                                    | Send StatsD metrics through the OpenTelemetry Collector                   |
| [Syslog Proxy](/send-data/syslog-proxy)                        | Forward syslog data with transformation                                   |
| [Traefik](/send-data/traefik)                                  | Scrape Traefik metrics with the OpenTelemetry Collector                   |
| [Tremor](/send-data/tremor)                                    | Event processing system for complex workflows                             |
| [Winston](/guides/winston)                                     | Popular Node.js logging library                                           |
| [Zap](/guides/zap)                                             | Uber’s fast, structured Go logger                                         |

## Amazon Web Services (AWS) [#amazon-web-services-aws]

Axiom offers deep integration with the AWS ecosystem.

| Method                                                  | Description                           |
| :------------------------------------------------------ | :------------------------------------ |
| [Amazon CloudFront](/send-data/cloudfront)              | CDN access logs and real-time logs    |
| [Amazon CloudWatch](/send-data/cloudwatch)              | Stream logs from CloudWatch Logs      |
| [Amazon Kinesis Data Firehose](/send-data/aws-firehose) | Real-time streaming with Firehose     |
| [Amazon S3](/send-data/aws-s3)                          | Process logs stored in S3 buckets     |
| [AWS FireLens](/send-data/aws-firelens)                 | Container log routing for ECS/Fargate |
| [AWS IoT Rules](/send-data/aws-iot-rules)               | Route IoT device data and telemetry   |
| [AWS Lambda](/send-data/aws-lambda)                     | Serverless function logs and traces   |
| [AWS Lambda .NET](/send-data/aws-lambda-dot)            | .NET-specific Lambda integration      |

## Example configurations [#example-configurations]

The following examples show how to send data using OpenTelemetry from various languages and frameworks.

| Application                                                    | Description                                     |
| :------------------------------------------------------------- | :---------------------------------------------- |
| [OpenTelemetry .NET](/guides/opentelemetry-dotnet)             | Complete .NET app example                       |
| [OpenTelemetry Claude Code](/guides/opentelemetry-claude-code) | Monitor Claude Code usage with metrics and logs |
| [OpenTelemetry Django](/guides/opentelemetry-django)           | Python Django with OpenTelemetry                |
| [OpenTelemetry Go](/guides/opentelemetry-go)                   | Go app with full observability                  |
| [OpenTelemetry Java](/guides/opentelemetry-java)               | Java Spring Boot example                        |
| [OpenTelemetry Next.js](/guides/opentelemetry-nextjs)          | Full-stack Next.js with tracing                 |
| [OpenTelemetry Node.js](/guides/opentelemetry-nodejs)          | Node.js Express example                         |
| [OpenTelemetry Nuxt.js](/guides/opentelemetry-nuxtjs)          | Nuxt.js with server-side tracing                |
| [OpenTelemetry Python](/guides/opentelemetry-python)           | Python Flask/FastAPI example                    |
| [OpenTelemetry Ruby](/guides/opentelemetry-ruby)               | Ruby on Rails with OpenTelemetry                |

<Info>
  If you need an ingestion method that isn’t in the list above, [contact Axiom](https://www.axiom.co/contact).
</Info>

## Limits on ingested data [#limits-on-ingested-data]

For more information on limits and requirements imposed by Axiom, see [Limits](/reference/limits).