Tenant Usage Tracking

import httpx
from typing import Optional

async def get_tenant_usage(
    workspace_id: str,
    from_period: Optional[str] = None,
    to_period: Optional[str] = None,
    page: int = 1,
    per_page: int = 50
):
    headers = _get_auth_headers(workspace_id, API_KEY_ID, SECRET_KEY)

    params = {"page": page, "per_page": per_page}
    if from_period:
        params["from_period"] = from_period
    if to_period:
        params["to_period"] = to_period

    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"{PAPERMAP_API_URL}/api/v1/external/workspaces/{workspace_id}/tenant-usage",
            headers=headers,
            params=params
        )

    return response.json()

# Example usage
usage = await get_tenant_usage("ws-123", from_period="2025-01", to_period="2025-12")
for item in usage["data"]["usage"]:
    print(f"Tenant {item['tenant_id']}: {item['credits_used']} credits")

import axios from "axios";

interface TenantUsageItem {
  tenant_id: string;
  period: string;
  period_start: string;
  period_end: string;
  credits_used: number;
  request_count: number;
}

async function getTenantUsage(
  workspaceId: string,
  fromPeriod?: string,
  toPeriod?: string,
  page: number = 1,
  perPage: number = 50
): Promise<TenantUsageItem[]> {
  const service = new DashboardAPIService({
    apiKeyId: process.env.PAPERMAP_API_KEY_ID,
    secretKey: process.env.PAPERMAP_SECRET_KEY,
    workspaceId: workspaceId,
    baseUrl: process.env.PAPERMAP_API_URL,
  });

  const headers = service.getAuthHeaders();

  const params: Record<string, string> = {
    page: page.toString(),
    per_page: perPage.toString(),
  };
  if (fromPeriod) params.from_period = fromPeriod;
  if (toPeriod) params.to_period = toPeriod;

  const response = await axios.get(
    `${service.config.baseUrl}/api/v1/external/workspaces/${workspaceId}/tenant-usage`,
    { headers, params }
  );

  return response.data.data.usage;
}

// Example usage
const usage = await getTenantUsage("ws-123", "2025-01", "2025-12");
usage.forEach((item) => {
  console.log(`Tenant ${item.tenant_id}: ${item.credits_used} credits`);
});

<?php
function getTenantUsage(
    $workspaceId,
    $fromPeriod = null,
    $toPeriod = null,
    $page = 1,
    $perPage = 50
) {
    $headers = getAuthHeaders(
        $workspaceId,
        getenv('PAPERMAP_API_KEY_ID'),
        getenv('PAPERMAP_SECRET_KEY')
    );

    $params = ['page' => $page, 'per_page' => $perPage];
    if ($fromPeriod) $params['from_period'] = $fromPeriod;
    if ($toPeriod) $params['to_period'] = $toPeriod;

    $url = getenv('PAPERMAP_API_URL')
        . '/api/v1/external/workspaces/' . $workspaceId . '/tenant-usage?'
        . http_build_query($params);

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $headerArray = [];
    foreach ($headers as $key => $value) {
        $headerArray[] = "$key: $value";
    }
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headerArray);

    $response = curl_exec($ch);
    curl_close($ch);

    return json_decode($response, true);
}

// Example usage
$usage = getTenantUsage('ws-123', '2025-01', '2025-12');
foreach ($usage['data']['usage'] as $item) {
    echo "Tenant {$item['tenant_id']}: {$item['credits_used']} credits\n";
}
?>

public TenantUsageResponse getTenantUsage(
    String workspaceId,
    String fromPeriod,
    String toPeriod,
    int page,
    int perPage
) throws Exception {
    HttpHeaders headers = getAuthHeaders(workspaceId);

    UriComponentsBuilder builder = UriComponentsBuilder
        .fromHttpUrl(baseUrl + "/api/v1/external/workspaces/" + workspaceId + "/tenant-usage")
        .queryParam("page", page)
        .queryParam("per_page", perPage);

    if (fromPeriod != null) builder.queryParam("from_period", fromPeriod);
    if (toPeriod != null) builder.queryParam("to_period", toPeriod);

    HttpEntity<Void> request = new HttpEntity<>(headers);

    ResponseEntity<TenantUsageResponse> response = restTemplate.exchange(
        builder.toUriString(),
        HttpMethod.GET,
        request,
        TenantUsageResponse.class
    );

    return response.getBody();
}

public async Task<TenantUsageResponse> GetTenantUsage(
    string workspaceId,
    string fromPeriod = null,
    string toPeriod = null,
    int page = 1,
    int perPage = 50
)
{
    var headers = GetAuthHeaders(workspaceId);

    var queryParams = new List<string>
    {
        $"page={page}",
        $"per_page={perPage}"
    };
    if (!string.IsNullOrEmpty(fromPeriod))
        queryParams.Add($"from_period={fromPeriod}");
    if (!string.IsNullOrEmpty(toPeriod))
        queryParams.Add($"to_period={toPeriod}");

    var url = $"{_baseUrl}/api/v1/external/workspaces/{workspaceId}/tenant-usage?{string.Join("&", queryParams)}";

    var request = new HttpRequestMessage(HttpMethod.Get, url);
    foreach (var header in headers)
    {
        request.Headers.Add(header.Key, header.Value);
    }

    var response = await _httpClient.SendAsync(request);
    var content = await response.Content.ReadAsStringAsync();

    return JsonSerializer.Deserialize<TenantUsageResponse>(content);
}

func (s *DashboardAPIService) GetTenantUsage(
    workspaceID string,
    fromPeriod string,
    toPeriod string,
    page int,
    perPage int,
) (*TenantUsageResponse, error) {
    headers := s.getAuthHeaders(workspaceID)

    url := fmt.Sprintf(
        "%s/api/v1/external/workspaces/%s/tenant-usage?page=%d&per_page=%d",
        s.BaseURL, workspaceID, page, perPage,
    )
    if fromPeriod != "" {
        url += "&from_period=" + fromPeriod
    }
    if toPeriod != "" {
        url += "&to_period=" + toPeriod
    }

    req, _ := http.NewRequest("GET", url, nil)

    for key, value := range headers {
        req.Header.Set(key, value)
    }

    resp, err := s.Client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    var result TenantUsageResponse
    json.NewDecoder(resp.Body).Decode(&result)

    return &result, nil
}