# 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**

```bash
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**

```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**

```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**

```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**

```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(())
}
```