
{}

Examples:
  # Run with local file storage:
  1. influxdb3 serve --node-id node1 --object-store file --data-dir ~/.influxdb_data
  2. influxdb3 create token --admin
  3. Write and query with token

  # Run with AWS S3:
  1. influxdb3 serve --node-id node1 --object-store s3 --bucket influxdb-data \
    --aws-access-key-id KEY --aws-secret-access-key SECRET
  2. influxdb3 create token --admin
  3. Write and query with token

  # Run with Azure Blob Storage:
  1. influxdb3 serve --node-id node1 --object-store azure --bucket influxdb-data \
    --azure-storage-account STORAGE_ACCOUNT \
    --azure-storage-access-key STORAGE_ACCESS_KEY
  2. influxdb3 create token --admin
  3. Write and query with token

{} [OPTIONS] --node-id <NODE_IDENTIFIER_PREFIX> --object-store <OBJECT_STORE_TYPE>

{}
  --node-id <NODE_ID>                          Node identifier used as prefix in object store file paths
                                                 [env: INFLUXDB3_NODE_ID=]
  --node-id-from-env <VARNAME>                 Obtain the node id from the specified environment variable; conflicts with --node-id flag
                                                 [env: INFLUXDB3_NODE_ID_FROM_ENV=]
  --object-store <STORE>                       Object storage to use
                                                 [possible values: memory, memory-throttled, file, s3, google, azure]

{}
  --http-bind <ADDR>                           Address for HTTP API requests [default: 0.0.0.0:8181]
                                                 [env: INFLUXDB3_HTTP_BIND_ADDR=]
  --shutdown-timeout <DURATION>                Maximum time to wait for active connections to drain during
                                               shutdown. Remaining connections are forcibly closed when the
                                               timeout expires. Set to 0s to close connections immediately.
                                                 [default: 30s]
                                                 [env: INFLUXDB3_SHUTDOWN_TIMEOUT=]
  --log-filter <FILTER>                        Logs: filter directive. When the filter starts with "debug" or "trace",
                                               noise-reduction directives are automatically appended (e.g. reqwest=info,
                                               datafusion=info, object_store_metrics=info). Use --disable-log-filter-noise-reduction
                                               to suppress this.
                                                 [default: info,iox_query::query_log=warn,influxdb3_query_executor::query_planner=warn]
                                                 [env: INFLUXDB3_LOG_FILTER=]
  --disable-log-filter-noise-reduction         When set, debug/trace log filters are not automatically
                                               expanded with noise-reduction directives.
                                                 [env: INFLUXDB3_DISABLE_LOG_FILTER_NOISE_REDUCTION=]

{}
  --tls-key <KEY_FILE>                         The path to the key file for TLS to be enabled
                                                 [env: INFLUXDB3_TLS_KEY=]
  --tls-cert <CERT_FILE>                       The path to the cert file for TLS to be enabled
                                                 [env: INFLUXDB3_TLS_CERT=]
  --tls-minimum-version <VERSION>              The minimum version for TLS. Valid values are
                                               tls-1.2 and tls-1.3, default is tls-1.2
                                                 [env: INFLUXDB3_TLS_MINIMUM_VERSION=]
  --without-auth                               Run InfluxDB 3 server without authorization
  --disable-authz <RESOURCES>                  Optionally disable authz by passing in a comma separated
                                               list of resources. Valid values are health, ping, metrics,
                                               ready, and pprof. To disable auth for multiple resources
                                               pass in a list, eg. `--disable-authz health,ping`
  --admin-token-recovery-http-bind <ADDR>      Enable admin token recovery endpoint. Use flag alone for default
                                               address (127.0.0.1:8182) or with value for custom address.
                                               WARNING: This endpoint allows unauthenticated admin token regeneration!
                                                 [env: INFLUXDB3_ADMIN_TOKEN_RECOVERY_HTTP_BIND_ADDR=]
  --admin-token-file <FILE>                    File containing offline admin tokens
                                               The token will be loaded at server startup if no admin token exists.
                                               Generated using: influxdb3 create token --admin --offline
                                                 [env: INFLUXDB3_ADMIN_TOKEN_FILE=]

{}
  --data-dir <DIR>                             Location to store files locally
                                                 [env: INFLUXDB3_DATA_DIR=]
  --bucket <BUCKET>                            Bucket name for cloud object storage
                                                 [env: INFLUXDB3_BUCKET=]


  {}
  --aws-access-key-id <KEY>                    S3 access key ID [default: ]
                                                 [env: AWS_ACCESS_KEY_ID=]
  --aws-secret-access-key <KEY>                S3 secret access key [default: ]
                                                 [env: AWS_SECRET_ACCESS_KEY=]
  --aws-default-region <REGION>                S3 region [default: us-east-1]
                                                 [env: AWS_DEFAULT_REGION=]
  --aws-endpoint <ENDPOINT>                    S3 compatibility endpoint
                                                 [env: AWS_ENDPOINT=]
  --aws-session-token <TOKEN>                  S3 session token for federated login/SSO
                                                 [env: AWS_SESSION_TOKEN=]
  --aws-allow-http                             Allow unencrypted HTTP to AWS
                                                 [env: AWS_ALLOW_HTTP=]
  --aws-skip-signature                         Skip request signing
                                                 [env: AWS_SKIP_SIGNATURE=]
  --aws-credentials-file <PATH>                S3 credentials file.
                                                 [env: AWS_CREDENTIALS_FILE]

                                               The format is JSON that looks like the following:

                                               {{
                                                 "aws_access_key_id": "<key>",
                                                 "aws_secret_access_key": "<secret>",
                                                 "aws_session_token": "<token>",
                                                 "expiry": "<expiry_timestamp_seconds_since_epoch>"
                                               }}

                                               Settings in this file override the corresponding CLI flags.

                                               The `aws_session_token` and `expiry` fields are optional and
                                               the file is automatically checked for updates at the expiry
                                               time if specified or at 1-hour intervals.

                                               If the object store returns an "Unauthenticated" error,
                                               InfluxDB3 will attempt to update its in-memory credentials
                                               from this file then retry the object store request.

  {}
  --azure-storage-account <ACCT>               Azure storage account name
                                                 [env: AZURE_STORAGE_ACCOUNT=]
  --azure-storage-access-key <KEY>             Azure storage access key
                                                 [env: AZURE_STORAGE_ACCESS_KEY=]
  --azure-endpoint <ENDPOINT>                  Azure blob storage endpoint
                                                 [env: AZURE_ENDPOINT=]
  --azure-allow-http                           Allow unencrypted HTTP to Azure
                                                 [env: AZURE_ALLOW_HTTP=]


  {}
  --google-service-account <PATH>              Path to Google credentials JSON
                                                 [env: GOOGLE_SERVICE_ACCOUNT=]


  {}
  --object-store-connection-limit <LIMIT>      Connection limit for network object stores [default: 16]
                                                 [env: INFLUXDB3_OBJECT_STORE_CONNECTION_LIMIT=]
  --object-store-http2-only                    Force HTTP/2 for object stores
                                                 [env: INFLUXDB3_OBJECT_STORE_HTTP2_ONLY=]
  --object-store-http2-max-frame-size <SIZE>   HTTP/2 max frame size
                                                 [env: INFLUXDB3_OBJECT_STORE_HTTP2_MAX_FRAME_SIZE=]
  --object-store-max-retries <N>               Max request retry attempts
                                                 [env: INFLUXDB3_OBJECT_STORE_MAX_RETRIES=]
  --object-store-retry-timeout <TIMEOUT>       Max retry timeout
                                                 [env: INFLUXDB3_OBJECT_STORE_RETRY_TIMEOUT=]
  --object-store-request-timeout <TIMEOUT>     HTTP request timeout for object store requests [default: 30s]
                                                 [env: INFLUXDB3_OBJECT_STORE_REQUEST_TIMEOUT=]
  --object-store-tls-allow-insecure            Skip TLS certificate verification for object storage.
                                               WARNING: This is insecure and should only be used for testing
                                                 [env: INFLUXDB3_OBJECT_STORE_TLS_ALLOW_INSECURE=]
  --object-store-tls-ca <PATH>                 Path to custom CA certificate file (PEM format) for object storage.
                                               Use when your object store uses a certificate signed by a private CA
                                                 [env: INFLUXDB3_OBJECT_STORE_TLS_CA=]

{}
  --plugin-dir <DIR>                           Location of plugins
                                                 [env: INFLUXDB3_PLUGIN_DIR=]
  --virtual-env-location <PATH>                Location of your virtual environment
                                                 [env: VIRTUAL_ENV=]
  --package-manager <MANAGER>                  Deprecated. Python and pip are bundled with InfluxDB; this option does not need to be set
                                                 [possible values: discover, pip, uv, disabled] [default: discover]
                                                 [env: INFLUXDB3_PACKAGE_MANAGER=]
  --disable-package-management                 Disable all Processing Engine package management. The server never
                                                 creates or modifies a virtual environment, never invokes pip, and
                                                 the plugin package-install API endpoints are rejected. Takes
                                                 precedence over --package-manager. Manage the virtual environment
                                                 yourself and point the server at it via VIRTUAL_ENV.
                                                 [env: INFLUXDB3_DISABLE_PACKAGE_MANAGEMENT=]
  --plugin-repo <URL>                          URL of plugin repository
                                                 [env: INFLUXDB3_PLUGIN_REPO=]
  --restrict-plugin-triggers-to <TYPE>...      Restrict plugin triggers to the provided trigger type(s)
                                                 [possible values: wal, schedule, request]
                                                 [env: INFLUXDB3_RESTRICT_PLUGIN_TRIGGERS_TO=]
  --async-trigger-concurrency-limit <N>        Maximum number of concurrent invocations per asynchronous trigger
                                               (run_asynchronous). Synchronous triggers always run one invocation
                                               at a time. Must be greater than zero. [default: unlimited]
                                               The default will change from unlimited to 8 in a future release.
                                                 [env: INFLUXDB3_ASYNC_TRIGGER_CONCURRENCY_LIMIT=]

{}
  --gen1-duration <DURATION>                   Duration for Parquet file arrangement [default: 10m]
                                                 [env: INFLUXDB3_GEN1_DURATION=]
  --gen1-lookback-duration <DURATION>          The amount of time that the server looks back on startup when
                                               populating the in-memory index of gen1 files.
                                                 [env: INFLUXDB3_GEN1_LOOKBACK_DURATION=]
  --delete-grace-period <DURATION>             Grace period for hard deleted databases and tables before they are
                                               removed permanently from the catalog [default: 24h]
                                                 [env: INFLUXDB3_DELETE_GRACE_PERIOD=]
  --retention-check-interval <INTERVAL>        The interval at which retention policies are checked and enforced.
                                               Enter as a human-readable time, e.g., '30m', '1h', etc. [default: 30m]
                                                 [env: INFLUXDB3_RETENTION_CHECK_INTERVAL=]

{}
  --wal-flush-interval <INTERVAL>                Interval to flush data to WAL file; shorter intervals
                                                 acknowledge writes sooner but produce smaller WAL files
                                                 and more object-store requests [default: 1s]
                                                   [env: INFLUXDB3_WAL_FLUSH_INTERVAL=]
  --wal-files-per-snapshot <N>                   Number of WAL files per snapshot; larger batches snapshot
                                                 more efficiently, smaller batches keep the query path and
                                                 compactor more current
                                                 [default: 600]
                                                   [aliases: wal-snapshot-size]
                                                   [env: INFLUXDB3_WAL_FILES_PER_SNAPSHOT=]
  --wal-max-buffered-writes <N>                  Nominal cap on write requests awaiting flush; memory is
                                                 bounded by --force-snapshot-mem-size, not this count
                                                 [default: 100000]
                                                   [aliases: wal-max-write-buffer-size]
                                                   [env: INFLUXDB3_WAL_MAX_BUFFERED_WRITES=]
  --wal-replay-concurrency-limit <LIMIT>         Concurrency limit during WAL replay [default: max(num_cpus, 10)]
                                                 Setting this number too high can lead to OOM.
                                                 The default is dynamically determined.
                                                   [env: INFLUXDB3_WAL_REPLAY_CONCURRENCY_LIMIT=]
  --snapshotted-wal-files-to-keep <N>            Number of snapshotted WAL files to retain [default: 300]
                                                   [env: INFLUXDB3_SNAPSHOTTED_WAL_FILES_TO_KEEP=]
  --wal-replay-fail-on-error                     Fail startup on corrupt WAL files instead of skipping them
                                                   [env: INFLUXDB3_WAL_REPLAY_FAIL_ON_ERROR=]
  --snapshot-concurrency-limit <N>               Max concurrent snapshot persistence tasks; setting this too
                                                 high can lead to OOM [default: number of CPUs]
                                                   [env: INFLUXDB3_SNAPSHOT_CONCURRENCY_LIMIT=]
  --checkpoint-interval <INTERVAL>               Interval between snapshot checkpoints, which aggregate
                                                 snapshots into one file per month to speed up startup
                                                 [default: disabled]
                                                   [env: INFLUXDB3_CHECKPOINT_INTERVAL=]

{}
  --last-cache-eviction-interval <INTERVAL>      Last-N-Value cache eviction interval [default: 10s]
                                                   [env: INFLUXDB3_LAST_CACHE_EVICTION_INTERVAL=]
  --distinct-cache-eviction-interval <INTERVAL>  Distinct Value cache eviction interval [default: 10s]
                                                   [env: INFLUXDB3_DISTINCT_CACHE_EVICTION_INTERVAL=]
  --query-log-max-entries <N>                    Maximum number of entries in the query log [default: 1000]
                                                   [aliases: query-log-size]
                                                   [env: INFLUXDB3_QUERY_LOG_MAX_ENTRIES=]
  --max-concurrent-queries <N>                   Maximum number of queries executing at once; further queries
                                                 wait until a running query completes. Lower values provide
                                                 backpressure during load spikes at the cost of queuing
                                                   [default: effectively unlimited (~2^60)]
                                                   [env: INFLUXDB3_MAX_CONCURRENT_QUERIES=]
  --query-file-limit <LIMIT>                     Max parquet files allowed in a query
                                                   [env: INFLUXDB3_QUERY_FILE_LIMIT=]

{}
  --max-http-request-size <SIZE>                 Maximum size of HTTP requests [default: 10mb]
                                                   [env: INFLUXDB3_MAX_HTTP_REQUEST_SIZE=]

{}
  --exec-mem-pool-size <SIZE>                         Memory budget for query execution; queries exceeding it
                                                      fail with a resource exhausted error instead of OOMing
                                                      [default: 20%]
                                                        [aliases: exec-mem-pool-bytes]
                                                        [env: INFLUXDB3_EXEC_MEM_POOL_SIZE=]
  --force-snapshot-mem-size <SIZE>                    Write-buffer memory at which a snapshot is forced to free
                                                      memory [default: 50%]
                                                        [env: INFLUXDB3_FORCE_SNAPSHOT_MEM_SIZE=]
  --file-cache-size <SIZE>                            In-memory data file cache size [default: 20%]
                                                        [env: INFLUXDB3_FILE_CACHE_SIZE=]
  --parquet-mem-cache-prune-percentage <PCT>          Percentage to prune from cache [default: 0.1]
                                                        [env: INFLUXDB3_PARQUET_MEM_CACHE_PRUNE_PERCENTAGE=]
  --parquet-mem-cache-prune-interval <INTERVAL>
                                                      Cache prune check interval [default: 1s]
                                                        [env: INFLUXDB3_PARQUET_MEM_CACHE_PRUNE_INTERVAL=]
  --file-cache-recency <DURATION>                     Duration to check for query path caching [default: 5h]
                                                        [aliases: parquet-mem-cache-query-path-duration]
                                                        [env: INFLUXDB3_FILE_CACHE_RECENCY=]
  --disable-file-cache                                Disable in-memory data file cache
                                                        [aliases: disable-parquet-mem-cache]
                                                        [env: INFLUXDB3_DISABLE_FILE_CACHE=]
  --table-index-cache-max-entries <N>                 Maximum number of table indices to cache in memory.
                                                      Set to 0 for unlimited cache size. [default: 100]
                                                        [env: INFLUXDB3_TABLE_INDEX_CACHE_MAX_ENTRIES=]
  --table-index-cache-concurrency-limit <N>           Maximum concurrent operations between table index cache and 
                                                      object store. This limits how many parallel requests can be 
                                                      made to object storage when loading or updating table indices. 
                                                        [default: 20]
                                                        [env: INFLUXDB3_TABLE_INDEX_CACHE_CONCURRENCY_LIMIT=]

{}
  --datafusion-num-threads <N>                        Max DataFusion runtime threads
                                                        [env: INFLUXDB3_DATAFUSION_NUM_THREADS=]
  --datafusion-runtime-type <TYPE>                    DataFusion runtime type [default: multi-thread]
                                                        [possible values: current-thread, multi-thread, multi-thread-alt]
                                                        [env: INFLUXDB3_DATAFUSION_RUNTIME_TYPE=]
  --datafusion-max-parquet-fanout <N>                 Parquet file fanout limit [default: 1000]
                                                        [env: INFLUXDB3_DATAFUSION_MAX_PARQUET_FANOUT=]
  --datafusion-use-cached-parquet-loader              Use cached parquet loader
                                                        [env: INFLUXDB3_DATAFUSION_USE_CACHED_PARQUET_LOADER=]
  --datafusion-config <CONFIG>                        Custom DataFusion configuration [default: ]
                                                        [env: INFLUXDB3_DATAFUSION_CONFIG=]
  --datafusion-runtime-disable-lifo-slot <BOOL>       Disable LIFO slot [possible values: true, false]
                                                        [env: INFLUXDB3_DATAFUSION_RUNTIME_DISABLE_LIFO_SLOT=]
  --datafusion-runtime-event-interval <N>             Scheduler ticks for polling external events
                                                        [env: INFLUXDB3_DATAFUSION_RUNTIME_EVENT_INTERVAL=]
  --datafusion-runtime-global-queue-interval <N>      Scheduler ticks for polling global task queue
                                                        [env: INFLUXDB3_DATAFUSION_RUNTIME_GLOBAL_QUEUE_INTERVAL=]
  --datafusion-runtime-max-blocking-threads <N>       Thread limit for DataFusion runtime
                                                        [env: INFLUXDB3_DATAFUSION_RUNTIME_MAX_BLOCKING_THREADS=]
  --datafusion-runtime-max-io-events-per-tick <N>     Max events per tick
                                                        [env: INFLUXDB3_DATAFUSION_RUNTIME_MAX_IO_EVENTS_PER_TICK=]
  --datafusion-runtime-thread-keep-alive <DURATION>   Blocking pool thread timeout
                                                        [env: INFLUXDB3_DATAFUSION_RUNTIME_THREAD_KEEP_ALIVE=]
  --datafusion-runtime-thread-priority <PRIORITY>     Thread priority [default: 10]
                                                        [env: INFLUXDB3_DATAFUSION_RUNTIME_THREAD_PRIORITY=]

{}
  --log-destination <DEST>                                     Logs: destination [default: stdout]
                                                                 [env: INFLUXDB3_LOG_DESTINATION=]
  --log-format <FORMAT>                                        Logs: message format [default: full]
                                                                 [env: INFLUXDB3_LOG_FORMAT=]
  --traces-exporter <TYPE>                                     Tracing: exporter type [default: none]
                                                                 [env: INFLUXDB3_TRACES_EXPORTER=]
  --traces-exporter-jaeger-agent-host <HOST>                   Jaeger agent hostname [default: 0.0.0.0]
                                                                 [env: INFLUXDB3_TRACES_EXPORTER_JAEGER_AGENT_HOST=]
  --traces-exporter-jaeger-agent-port <PORT>                   Jaeger agent port [default: 6831]
                                                                 [env: INFLUXDB3_TRACES_EXPORTER_JAEGER_AGENT_PORT=]
  --traces-exporter-jaeger-service-name <NAME>                 Jaeger service name [default: iox-conductor]
                                                                 [env: INFLUXDB3_TRACES_EXPORTER_JAEGER_SERVICE_NAME=]
  --traces-exporter-jaeger-trace-context-header-name <NAME>    Header for trace context [default: uber-trace-id]
                                                                 [env: INFLUXDB3_TRACES_EXPORTER_JAEGER_TRACE_CONTEXT_HEADER_NAME=]
  --traces-jaeger-debug-name <NAME>                            Header for force sampling [default: jaeger-debug-id]
                                                                 [env: INFLUXDB3_TRACES_EXPORTER_JAEGER_DEBUG_NAME=]
  --traces-jaeger-tags <TAGS>                                  Key-value pairs for tracing spans
                                                                 [env: INFLUXDB3_TRACES_EXPORTER_JAEGER_TAGS=]
  --traces-jaeger-max-msgs-per-second <N>                      Max messages per second [default: 1000]
                                                                 [env: INFLUXDB3_TRACES_JAEGER_MAX_MSGS_PER_SECOND=]


{}
  -v, --verbose             Increase logging verbosity
  -h, --help                Print help information
  --help-all                Print all available options

For more help on how to use InfluxDB 3 Core, go to https://docs.influxdata.com/influxdb3/core/
