> ## Documentation Index
> Fetch the complete documentation index at: https://docs.bronto.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Retrieve the list of metrics metadata sent to Bronto



## OpenAPI

````yaml https://s3.eu-west-1.amazonaws.com/docs.brontobytes.io/redocusaurus/brontobytes.yaml get /metrics
openapi: 3.0.2
info:
  title: Bronto API
  license:
    name: Commercial
  version: 1.0.0
servers:
  - url: https://api.eu.bronto.io
  - url: https://api.us.bronto.io
security:
  - ApiKeyAuth: []
  - BearerAuth: []
tags:
  - name: api-keys
    description: >
      An Application Programming Interface (API) key is a unique identifier. 

      The API Key must be provided as X-BRONTO-API-KEY in headers for the
      request to be authenticated 

      and authorized by the API server according to the API Key's role. For
      further information about 

      roles visit [our API Key docs] 
      https://docs.bronto.io/manage/manage-api-keys
  - name: context
    description: >
      Context is a REST API resource that allows the retrieval of a specified
      number of log events (default of 100) around 

      a log event of interest, e.g. when a number of log events were returned by
      a previous query and you then decide you 

      want to see the 50 log events before one of those returned log events. Log
      events can be retrieved either before, 

      after, or both before and after the specified log event.
  - name: exports
    description: >
      The Bronto Export API allows you to efficiently download large volumes of
      log data for further analysis.

      The data to be exported can be filtered by entering the search parameters
      \"from\", \"where\" and \"time_range\" as

      per a normal query in the \"search_details\" object.


      To export data the following steps are required:

      1. Create an export using a POST request, which will return an
      \"export_id\", \"status\" and \"progress\".

      2. Use the export id to get the status of the export task by sending a GET
      request,

      which will return \"status\" and \"progress\" with a value of percentage
      completed. When the export is

      completed, the \"status\" will be \"COMPLETE\"

      3. Once the export task has completed you can download your data using
      curl (or similar)

      from the \"location\" URL returned in the GET response.
  - name: collections
    description: >
      Collections group datasets together. Each collection contains one or more
      datasets.
  - name: datasets
    description: >
      Datasets are a sequence of timestamped log events. Datasets can be
      searched to view events matching a filter

      or to perform statistical functions on matching events.
  - name: logs
    description: >
      Logs are a sequence of timestamped log events. Logs can be searched to
      view events matching a filter

      or to perform statistical functions on matching events.
  - name: search
    description: >
      The REST API for searching data uses queries based on a subset of SQL,
      with

      the syntax as per https://docs.bronto.io/query-syntax/overview
  - name: top-keys
    description: >
      Top-Keys is a REST API resource that allows you to easily retrieve the top
      keys for a specific log.
  - name: significant-keys
    description: >
      Significant-Keys is a REST API resource for the stored, model-ranked keys
      of a log or of a set of

      metrics: which fields are worth charting, the golden signal each serves,
      and the metrics worth

      building on them. Rankings are current state, not history.
  - name: usage
    description: >
      Usage is a REST API resource that allows you to easily track your Bronto
      usage by retrieving usage data relating 

      to data ingestion and amount of data searched, and allowing you to drill
      down for a specific dataset over a defined timeframe.
  - name: users
    description: >
      Users are given specific roles, where each role determines the user's
      permissions within the application. Those roles are as follows:

      - "Admin" role has permission for all actions on all entities in the
      application.

      - "Standard" role allows Read/Write and Delete actions on entities in
      non-sensitive areas of the application.

      - "ReadOnly" role allows only read actions and only on entities in
      non-sensitive areas of the application.
  - name: config_assistant
    description: >
      The Config Assistant APIs provide endpoints for creating or modifying
      observability agent configurations.
  - name: patterns
    description: >
      Patterns return the Pattern IDs, templates, and source log ID for all logs
      matching the

      given search criteria.
  - name: metrics
    description: >
      Metrics are numeric time series ingested into Bronto, for example from
      OpenTelemetry collectors or SDKs. The Metrics endpoints return the
      metadata Bronto stores for each ingested metric, such as its name, type,
      unit and aggregation temporality, along with the keys and values received
      for it. They don't return datapoints. To query metric data, use the
      Timeseries API.
  - name: metric-definitions
    description: >
      Metric definitions are saved sets of queries and formulas that can be
      attached to widgets, monitors and SLOs. To compute a time series from a
      metric definition, use the Timeseries API.
  - name: timeseries
    description: >
      The Timeseries API computes time series and aggregations over log, trace
      and metric data. Use it to query the values of an ingested metric or to
      evaluate a metric definition.
  - name: audit
    description: >
      Bronto records audit events for actions taken in your account. The audit
      event schemas describe the structure of every audit event type.
paths:
  /metrics:
    get:
      tags:
        - metrics
      summary: Retrieve the list of metrics metadata sent to Bronto
      operationId: listMetrics
      parameters:
        - name: from_expr
          in: query
          description: >
            Expression used to select the set of metrics to return. The
            expression defines the criteria for which metrics are included and
            is applied across all available metrics to produce the result set.
            Supports logical operators (AND, OR), comparison operators (=, !=),
            and quoted string literals. The fields are `metric_id`,
            `metric_name`, `description`, `type`, `service` and the metric's
            tags by their exact key, e.g. `"Tag:environment"`. `service` and
            tags can hold several values; a comparison matches if any value
            matches, and a negated comparison matches if no value does. The
            parameter is optional; if it is not provided, all metrics are
            returned. If the expression matches no metrics, a 200 response with
            an empty `metrics` array is returned.
          required: false
          schema:
            type: string
          example: service = 'checkout' OR "Tag:environment" != 'production'
      responses:
        '200':
          description: list of metrics with metadata
          headers:
            RateLimit-Limit:
              $ref: '#/components/headers/RateLimitLimit'
            RateLimit-Remaining:
              $ref: '#/components/headers/RateLimitRemaining'
            RateLimit-Reset:
              $ref: '#/components/headers/RateLimitReset'
          content:
            application/json:
              schema:
                type: object
                properties:
                  metrics:
                    type: array
                    items:
                      $ref: '#/components/schemas/MetricMeta'
        '400':
          description: Bad Request - The body in the request is invalid.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              examples:
                bad_request:
                  summary: Bad Request
                  value:
                    code: 400
                    type: Bad Request
                    correlation_id: 95c6a974e3ab01209b6b0dfedb1b16c5
                    details: >-
                      Validation failed: 'name' field is required and cannot be
                      empty
        '404':
          description: Not Found - The metric definition is not found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        default:
          description: Unexpected Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              examples:
                unexpected_error:
                  summary: Unexpected error
                  value:
                    code: 500
                    type: Internal Server Error
                    correlation_id: b129b8e0e66c41aa9541a30f67e38ce2
                    details: Internal Server Error
components:
  headers:
    RateLimitLimit:
      description: The request limit per time window.
      schema:
        type: integer
      example: 20
    RateLimitRemaining:
      description: The number of requests left in the current time window.
      schema:
        type: integer
      example: 12
    RateLimitReset:
      description: The number of seconds left in the current time window.
      schema:
        type: integer
      example: 13
  schemas:
    MetricMeta:
      required:
        - metric_id
        - metric_name
        - type
      type: object
      properties:
        metric_id:
          maxLength: 36
          type: string
          description: unique identifier of the metric
          format: uuid
          example: b013a07d-aa13-47c1-9c74-635e42b22cbb
        metric_name:
          maxLength: 255
          minLength: 1
          type: string
          description: the name of the metric as ingested
          example: system.cpu.utilization
        description:
          maxLength: 255
          minLength: 0
          type: string
          description: the description of the metric if provided
          example: >-
            Difference in system.cpu.time since the last measurement per logical
            CPU, divided by the elapsed time (value in interval [0,1]).
        unit:
          maxLength: 20
          minLength: 1
          type: string
          description: the unit of the metric, if available
          example: s
        type:
          type: string
          description: the type of the metric
          example: GAUGE
          enum:
            - GAUGE
            - SUM
            - SUMMARY
            - HISTOGRAM
        aggregation_temporality:
          type: string
          description: >-
            the type of aggregation of the metric as ingested. Applies only to
            SUM and HISTOGRAM metrics
          example: DELTA
          enum:
            - DELTA
            - CUMULATIVE
        default_aggregation:
          type: string
          description: >-
            Suggested aggregation for the metric. Deprecated, use
            `default_query.aggregation` instead
          deprecated: true
          enum:
            - sum
            - avg
            - min
            - max
            - count
        default_query:
          type: object
          properties:
            aggregation:
              type: string
              description: >-
                Suggested aggregation function for the metric, e.g. `sum`,
                `avg`, `max`, `p99`, `rate`
              example: avg
            filter:
              type: string
              description: >-
                Suggested filter to apply to the metric. Empty if no filter is
                suggested
              example: service.name = 'checkout'
            group_by_keys:
              type: array
              description: >-
                Suggested tag keys to group the metric by. Empty if no grouping
                is suggested
              example:
                - Resource:host.name
              items:
                type: string
            chart_type:
              type: string
              description: >-
                Suggested chart type to display the metric. Empty if no chart
                type is suggested
              example: line
          description: Suggested query to use when charting the metric, if available
        metadata:
          type: object
          properties:
            last_heartbeat_at:
              type: integer
              description: >
                Timestamp of the last heartbeat in milliseconds since epoch,
                rounded to the start of the day. This should not be used as a
                liveness check as it may be delayed by up to 24 hours; consider
                querying the usage APIs instead.
              format: int64
              example: 1791331200000
          description: metadata of the object
      description: |
        Metadata for a metric sent to Bronto
    ErrorResponse:
      required:
        - code
        - correlation_id
        - details
        - type
      type: object
      properties:
        code:
          maximum: 599
          minimum: 400
          type: integer
          description: HTTP status code for the error response.
          format: int32
        type:
          type: string
          description: >-
            HTTP reason phrase associated with the status code (e.g. "Not Found"
            for 404)
          example: Not Found
        correlation_id:
          type: string
          description: Unique identifier for the request, used for tracing and debugging.
        details:
          type: string
          description: Human-readable description of the error.
          example: Resource not found.
      description: Standard error response returned by the API when a request fails.
      example:
        code: 404
        type: Not Found
        correlation_id: 605f832bcfe44a1081441691c8d42253
        details: Resource not found.
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      name: X-BRONTO-API-KEY
      in: header
    BearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.