curl -X POST "https://api.requestrocket.com/api/clients/${CLIENT_ID}/proxies/${PROXY_ID}/meters" \
  -H "Authorization: ${USER_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "meterType": "response_value",
    "meterActive": true,
    "extraction": {
      "location": "body",
      "path": "usage.total_tokens",
      "defaultValue": 0
    },
    "limits": {
      "day": 100000,
      "month": 2000000
    },
    "notes": "Track AI token usage per day and month"
  }'

const response = await fetch(
  `https://api.requestrocket.com/api/clients/${clientId}/proxies/${proxyId}/meters`,
  {
    method: 'POST',
    headers: {
      'Authorization': process.env.USER_TOKEN,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      meterType: 'response_value',
      meterActive: true,
      extraction: {
        location: 'body',
        path: 'usage.total_tokens',
        defaultValue: 0
      },
      limits: {
        day: 100000,
        month: 2000000
      },
      notes: 'Track AI token usage per day and month'
    })
  }
);

const data = await response.json();
console.log('Meter created:', data.meters[0]);

import requests
import os

client_id = "your-client-id"
proxy_id = "your-proxy-id"

response = requests.post(
    f'https://api.requestrocket.com/api/clients/{client_id}/proxies/{proxy_id}/meters',
    headers={'Authorization': os.getenv('USER_TOKEN')},
    json={
        'meterType': 'response_value',
        'meterActive': True,
        'extraction': {
            'location': 'body',
            'path': 'usage.total_tokens',
            'defaultValue': 0
        },
        'limits': {
            'day': 100000,
            'month': 2000000
        },
        'notes': 'Track AI token usage per day and month'
    }
)

data = response.json()
print(f"Meter created: {data['meters'][0]['sKey']}")

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

type MeterExtraction struct {
    Location     string  `json:"location"`
    Path         string  `json:"path"`
    DefaultValue float64 `json:"defaultValue"`
}

type MeterLimits struct {
    Day   int `json:"day"`
    Month int `json:"month"`
}

type MeterRequest struct {
    MeterType  string          `json:"meterType"`
    MeterActive bool           `json:"meterActive"`
    Extraction MeterExtraction `json:"extraction"`
    Limits     MeterLimits     `json:"limits"`
    Notes      string          `json:"notes"`
}

func main() {
    clientId := "your-client-id"
    proxyId := "your-proxy-id"

    requestBody, _ := json.Marshal(MeterRequest{
        MeterType:  "response_value",
        MeterActive: true,
        Extraction: MeterExtraction{
            Location:     "body",
            Path:         "usage.total_tokens",
            DefaultValue: 0,
        },
        Limits: MeterLimits{Day: 100000, Month: 2000000},
        Notes:  "Track AI token usage per day and month",
    })

    url := fmt.Sprintf("https://api.requestrocket.com/api/clients/%s/proxies/%s/meters", clientId, proxyId)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(requestBody))
    req.Header.Set("Authorization", os.Getenv("USER_TOKEN"))
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.http.*;
import java.net.URI;

public class CreateMeter {
    public static void main(String[] args) throws Exception {
        String clientId = "your-client-id";
        String proxyId = "your-proxy-id";
        String json = "{"
            + "\"meterType\": \"response_value\","
            + "\"meterActive\": true,"
            + "\"extraction\": {"
            + "  \"location\": \"body\","
            + "  \"path\": \"usage.total_tokens\","
            + "  \"defaultValue\": 0"
            + "},"
            + "\"limits\": {\"day\": 100000, \"month\": 2000000},"
            + "\"notes\": \"Track AI token usage per day and month\""
            + "}";

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.requestrocket.com/api/clients/" + clientId + "/proxies/" + proxyId + "/meters"))
            .header("Authorization", System.getenv("USER_TOKEN"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(json))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

curl -X GET "https://api.requestrocket.com/api/clients/${CLIENT_ID}/proxies/${PROXY_ID}/meters" \
  -H "Authorization: ${USER_TOKEN}"

const response = await fetch(
  `https://api.requestrocket.com/api/clients/${clientId}/proxies/${proxyId}/meters`,
  {
    headers: {
      'Authorization': process.env.USER_TOKEN
    }
  }
);

const data = await response.json();
console.log('Meters:', data.meters);

import requests
import os

client_id = "your-client-id"
proxy_id = "your-proxy-id"

response = requests.get(
    f'https://api.requestrocket.com/api/clients/{client_id}/proxies/{proxy_id}/meters',
    headers={'Authorization': os.getenv('USER_TOKEN')}
)

data = response.json()
print(f"Found {len(data['meters'])} meters")

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

type Response struct {
    Meters  []map[string]interface{} `json:"meters"`
    Message string                   `json:"message"`
}

func main() {
    clientId := "your-client-id"
    proxyId := "your-proxy-id"

    url := fmt.Sprintf("https://api.requestrocket.com/api/clients/%s/proxies/%s/meters", clientId, proxyId)
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Set("Authorization", os.Getenv("USER_TOKEN"))

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var result Response
    json.Unmarshal(body, &result)

    fmt.Printf("Found %d meters\n", len(result.Meters))
}

import java.net.http.*;
import java.net.URI;
import com.google.gson.*;

public class ListMeters {
    public static void main(String[] args) throws Exception {
        String clientId = "your-client-id";
        String proxyId = "your-proxy-id";

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.requestrocket.com/api/clients/" + clientId + "/proxies/" + proxyId + "/meters"))
            .header("Authorization", System.getenv("USER_TOKEN"))
            .GET()
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        JsonObject json = JsonParser.parseString(response.body()).getAsJsonObject();
        JsonArray meters = json.getAsJsonArray("meters");
        System.out.println("Found " + meters.size() + " meters");
    }
}

curl -X PUT "https://api.requestrocket.com/api/clients/${CLIENT_ID}/proxies/${PROXY_ID}/meters/${METER_ID}" \
  -H "Authorization: ${USER_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "meterActive": false,
    "limits": {
      "day": 50000,
      "month": 1000000
    }
  }'

const response = await fetch(
  `https://api.requestrocket.com/api/clients/${clientId}/proxies/${proxyId}/meters/${meterId}`,
  {
    method: 'PUT',
    headers: {
      'Authorization': process.env.USER_TOKEN,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      meterActive: false,
      limits: {
        day: 50000,
        month: 1000000
      }
    })
  }
);

const data = await response.json();
console.log('Meter updated:', data.meters[0]);

import requests
import os

client_id = "your-client-id"
proxy_id = "your-proxy-id"
meter_id = "your-meter-id"

response = requests.put(
    f'https://api.requestrocket.com/api/clients/{client_id}/proxies/{proxy_id}/meters/{meter_id}',
    headers={'Authorization': os.getenv('USER_TOKEN')},
    json={
        'meterActive': False,
        'limits': {
            'day': 50000,
            'month': 1000000
        }
    }
)

data = response.json()
print(f"Meter updated: {data['meters'][0]['sKey']}")

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

type MeterUpdate struct {
    MeterActive bool        `json:"meterActive"`
    Limits      MeterLimits `json:"limits"`
}

type MeterLimits struct {
    Day   int `json:"day"`
    Month int `json:"month"`
}

func main() {
    clientId := "your-client-id"
    proxyId := "your-proxy-id"
    meterId := "your-meter-id"

    requestBody, _ := json.Marshal(MeterUpdate{
        MeterActive: false,
        Limits:      MeterLimits{Day: 50000, Month: 1000000},
    })

    url := fmt.Sprintf("https://api.requestrocket.com/api/clients/%s/proxies/%s/meters/%s", clientId, proxyId, meterId)
    req, _ := http.NewRequest("PUT", url, bytes.NewBuffer(requestBody))
    req.Header.Set("Authorization", os.Getenv("USER_TOKEN"))
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.http.*;
import java.net.URI;

public class UpdateMeter {
    public static void main(String[] args) throws Exception {
        String clientId = "your-client-id";
        String proxyId = "your-proxy-id";
        String meterId = "your-meter-id";
        String json = "{"
            + "\"meterActive\": false,"
            + "\"limits\": {\"day\": 50000, \"month\": 1000000}"
            + "}";

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.requestrocket.com/api/clients/" + clientId + "/proxies/" + proxyId + "/meters/" + meterId))
            .header("Authorization", System.getenv("USER_TOKEN"))
            .header("Content-Type", "application/json")
            .PUT(HttpRequest.BodyPublishers.ofString(json))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

curl -X DELETE "https://api.requestrocket.com/api/clients/${CLIENT_ID}/proxies/${PROXY_ID}/meters/${METER_ID}" \
  -H "Authorization: ${USER_TOKEN}"

const response = await fetch(
  `https://api.requestrocket.com/api/clients/${clientId}/proxies/${proxyId}/meters/${meterId}`,
  {
    method: 'DELETE',
    headers: {
      'Authorization': process.env.USER_TOKEN
    }
  }
);

const data = await response.json();
console.log(data.message);

import requests
import os

client_id = "your-client-id"
proxy_id = "your-proxy-id"
meter_id = "your-meter-id"

response = requests.delete(
    f'https://api.requestrocket.com/api/clients/{client_id}/proxies/{proxy_id}/meters/{meter_id}',
    headers={'Authorization': os.getenv('USER_TOKEN')}
)

data = response.json()
print(data['message'])

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

type Response struct {
    Message string `json:"message"`
}

func main() {
    clientId := "your-client-id"
    proxyId := "your-proxy-id"
    meterId := "your-meter-id"

    url := fmt.Sprintf("https://api.requestrocket.com/api/clients/%s/proxies/%s/meters/%s", clientId, proxyId, meterId)
    req, _ := http.NewRequest("DELETE", url, nil)
    req.Header.Set("Authorization", os.Getenv("USER_TOKEN"))

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var result Response
    json.Unmarshal(body, &result)

    fmt.Println(result.Message)
}

import java.net.http.*;
import java.net.URI;
import com.google.gson.*;

public class DeleteMeter {
    public static void main(String[] args) throws Exception {
        String clientId = "your-client-id";
        String proxyId = "your-proxy-id";
        String meterId = "your-meter-id";

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.requestrocket.com/api/clients/" + clientId + "/proxies/" + proxyId + "/meters/" + meterId))
            .header("Authorization", System.getenv("USER_TOKEN"))
            .DELETE()
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        JsonObject json = JsonParser.parseString(response.body()).getAsJsonObject();
        System.out.println(json.get("message").getAsString());
    }
}