v0/endpoints/{id}/rate-limits REST API Endpoint

Updates endpoint rate limits.

Updated on

Jun 26, 2026

Path Parameters

id
string
REQUIRED
The unique identifier for the specific endpoint

Body Parameters

rate_limits
object
REQUIRED
Contains the rate limit configurations that you want to update

rps
integer
Specifies the maximum number of requests allowed per second

rpd
integer
Specifies the maximum number of requests allowed per day

rpm
integer
Specifies the maximum number of requests allowed per minute

Returns

data
object
The data object which contains the following fields:

limits
object
The limits object which contains the following fields:

rps
integer
The maximum number of requests allowed per second. A value of -1 indicates that no endpoint-level override is set for this bucket.

rpd
integer
The maximum number of requests allowed per day. A value of -1 indicates that no endpoint-level override is set for this bucket.

rpm
integer
The maximum number of requests allowed per minute. A value of -1 indicates that no endpoint-level override is set for this bucket.

error
string
A field containing an error message if any issue occurs

Request

Curl

curl -X 'PATCH' \
  'https://api.quicknode.com/v0/endpoints/{id}/rate-limits' \
  -H 'accept: */*' \
  -H 'x-api-key: YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "rate_limits": {
        "rps": 300
    }
}'

JavaScript

const myHeaders = new Headers();
myHeaders.append("accept", "*/*");
myHeaders.append("x-api-key", "YOUR_API_KEY");
myHeaders.append("Content-Type", "application/json");

const raw = JSON.stringify({
  "rate_limits": {
    "rps": 300
  }
});

const requestOptions = {
  method: "PATCH",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("https://api.quicknode.com/v0/endpoints/{id}/rate-limits", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

Python

import requests
import json

url = "https://api.quicknode.com/v0/endpoints/{id}/rate-limits"

payload = json.dumps({
  "rate_limits": {
    "rps": 300
  }
})
headers = {
  'accept': '*/*',
  'x-api-key': 'YOUR_API_KEY',
  'Content-Type': 'application/json',
}

response = requests.request("PATCH", url, headers=headers, data=payload)
print(response.text)

Ruby

require "uri"
require "json"
require "net/http"

url = URI("https://api.quicknode.com/v0/endpoints/{id}/rate-limits")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["accept"] = "*/*"
request["x-api-key"] = "YOUR_API_KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "rate_limits": {
    "rps": 300
  }
})

response = https.request(request)
puts response.read_body

Rust

use quicknode_sdk::admin::{RateLimitSettings, UpdateRateLimitsRequest};
use quicknode_sdk::{QuicknodeSdk, SdkFullConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let qn = QuicknodeSdk::new(
        &SdkFullConfig::builder()
            .api_key("YOUR_API_KEY".to_string())
            .build(),
    )?;
    let response = qn
        .admin
        .update_rate_limits(
            "ENDPOINT_ID",
            &UpdateRateLimitsRequest {
                rate_limits: RateLimitSettings {
                    rps: Some(100),
                    rpm: Some(1000),
                    rpd: Some(10000),
                },
            },
        )
        .await?;

println!("{:?}", response);
    Ok(())
}