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

# Get daily account usage

> Returns one entry per UTC day for a single account, so a multi-day traffic chart costs one request instead of one per day.

Both `from` and `to` are required and the range may not exceed **90 days**. Days with no traffic are returned with zeroed counters, so the series is always contiguous and needs no gap handling.

Data is sourced from an hourly rollup that lags roughly 90 minutes and begins on 2026-04-10, so days before that date return zeros. Use this endpoint for **historical charts**, not for real-time or lifetime usage — for cumulative usage against an account's allowance, read `used_bytes` from `GET /accounts`.



## OpenAPI

````yaml get /accounts/{id}/usage/daily
openapi: 3.0.1
info:
  title: Proxy Resellers API
  x-logo:
    url: logo192.png
    altText: Massive Proxy Resellers API
  description: >
    The Proxy Resellers API allows to manage proxy resellers accounts.

    The accounts created via this API are used to authenticate the Network API
    (see below "Using Credentials).


    ## Features

    - Create an account

    - Update an account

    - Get list of accounts created

    - Enable/Disable account

    - Manage account domains blocklist

    - Set per-session traffic/duration limits for a sub-account

    - Allocate traffic for account

    - Get list of allocations made for account

    - Get current account traffic usage


    ## Authorization

    The API uses API key for authorization. The API key should be included in
    the request header as `x-api-key`.


    Please note that the API key provided for the Network API is not
    automatically enabled for this API, enabling it must be requested to Massive
    support.


    ## Using Credentials

    Successfully created account will have the following credentials to access
    the Massive Network:

    - Username: `<customerUsername>_<accountUsername>`

    - Password: `<accountPassword>`


    **The account will be linked to the customer but have own credentials to
    access the Massive Network.**


    ### Example

    Request:

    ```sh

    curl --location 'https://api-network.joinmassive.com/resellers/accounts' \

    --header 'Content-Type: application/json' \

    --header 'x-api-key: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' \

    --data-raw '{
      "username": "johndoe@example.com",
      "password": "isdnf8eh8weun823"
    }'

    ```


    Request to the Massive Network considering that x-api-key belongs to the
    demo@joinmassive.com account:

    ```sh

    curl -x 'https://network.joinmassive.com:65535' \

    -U 'demo@joinmassive.com_johndoe@example.com:isdnf8eh8weun823'

    ```


    _demo@joinmassive.com_johndoe@example.com_ is a username and targeting
    params can be provided according to the Massive Network documentation.
  version: v1
servers:
  - url: https://api-network.joinmassive.com/resellers
security: []
paths:
  /accounts/{id}/usage/daily:
    get:
      tags:
        - Usage
      summary: Get daily account usage
      description: >-
        Returns one entry per UTC day for a single account, so a multi-day
        traffic chart costs one request instead of one per day.


        Both `from` and `to` are required and the range may not exceed **90
        days**. Days with no traffic are returned with zeroed counters, so the
        series is always contiguous and needs no gap handling.


        Data is sourced from an hourly rollup that lags roughly 90 minutes and
        begins on 2026-04-10, so days before that date return zeros. Use this
        endpoint for **historical charts**, not for real-time or lifetime usage
        — for cumulative usage against an account's allowance, read `used_bytes`
        from `GET /accounts`.
      operationId: getAccountUsageDaily
      parameters:
        - name: from
          in: query
          required: true
          description: Start of the range, inclusive, as a Unix timestamp in seconds.
          schema:
            type: string
            example: '1754006400'
        - name: to
          in: query
          required: true
          description: >-
            End of the range, exclusive, as a Unix timestamp in seconds. Must be
            after `from` and no more than 90 days later.
          schema:
            type: string
            example: '1756598400'
        - name: id
          in: path
          required: true
          schema:
            type: string
      responses:
        '200':
          description: One entry per UTC day in the requested range.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/usageDailyResponseOK'
        '400':
          $ref: '#/components/responses/BadRequestError'
        '401':
          $ref: '#/components/responses/UnauthorizedError'
        '403':
          $ref: '#/components/responses/ForbiddenError'
        '404':
          $ref: '#/components/responses/AccountNotFound'
        '500':
          $ref: '#/components/responses/InternalServerError'
      security:
        - api-key: []
components:
  schemas:
    usageDailyResponseOK:
      type: array
      items:
        type: object
        properties:
          date:
            type: string
            format: date
            description: The UTC day, as YYYY-MM-DD.
            example: '2026-08-01'
          used_bytes:
            type: integer
            description: Bytes of traffic used by the account on this day.
            example: 1336682714
          total_requests:
            type: integer
            description: Requests made by the account on this day.
            example: 20462
          successful_requests:
            type: integer
            description: Of those, the requests that succeeded.
            example: 20283
  responses:
    BadRequestError:
      description: >-
        The request is invalid (more details can be found in the error message
        in the body).
      content:
        application/json:
          schema:
            type: object
            properties:
              error:
                type: string
                description: The error message.
                example: 'Invalid request: <details>'
    UnauthorizedError:
      description: Operation not authorized
      content:
        application/json:
          schema:
            type: object
            properties:
              error:
                type: string
                description: The error message.
                example: Unauthorized
    ForbiddenError:
      description: Operation forbidden
      content:
        application/json:
          schema:
            type: object
            properties:
              error:
                type: string
                description: The error message.
                example: Forbidden
    AccountNotFound:
      description: AccountNotFound
      content:
        application/json:
          schema:
            type: object
            properties:
              error:
                type: string
                description: The error message.
                example: Account not found
    InternalServerError:
      description: Internal Server error
      content:
        application/json:
          schema:
            type: object
            properties:
              error:
                type: string
                description: The error message.
                example: Internal server error
  securitySchemes:
    api-key:
      type: apiKey
      name: x-api-key
      in: header

````