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

#### Creates a method rate limit.

Updated on

Jun 26, 2026

#### Path Parameters

id  
string  
REQUIRED  
The unique identifier for the specific endpoint

#### Body Parameters

- **interval**  
  string  
  REQUIRED  
  Specifies the time interval for the rate limit; valid values include second, minute or hour  
- **methods**  
  array  
  REQUIRED  
  An array of method names to which the rate limiter applies  
- **rate**  
  integer  
  REQUIRED  
  Specifies the maximum number of requests allowed for the specified methods within the defined interval

### Returns

- **data**  
  object  
  The data object which contains the following fields:  
  - **id**  
    string  
    A unique identifier for the rate limiter  
  - **interval**  
    string  
    The time interval for the rate limit  
  - **methods**  
    array  
    A list of methods the rate limiter applies to  
  - **rate**  
    integer  
    The maximum number of requests allowed within the specified interval  
  - **status**  
    string  
    The current status of the rate limiter  
  - **created**  
    string  
    The timestamp when the rate limiter was created in second  
  - **error**  
    string  
    A field containing an error message if any issue occurs

### Request

**Curl**

```bash
curl -X 'POST' \
  'https://api.quicknode.com/v0/endpoints/{id}/method-rate-limits' \
  -H 'accept: application/json' \
  -H 'x-api-key: YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{\n  "interval": "second",\n  "methods": [\n    "eth_getLogs"\n  ],\n  "rate": 10\n}'
```

**JavaScript**

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

const raw = JSON.stringify({
  "interval": "second",
  "methods": [
    "eth_getLogs"
  ],
  "rate": 10
});

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

fetch("https://api.quicknode.com/v0/endpoints/{id}/method-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}/method-rate-limits"
payload = json.dumps({
  "interval": "second",
  "methods": [
    "eth_getLogs"
  ],
  "rate": 10
})
headers = {
  'accept': 'application/json',
  'x-api-key': 'YOUR_API_KEY',
  'Content-Type': 'application/json',
}
response = requests.request("POST", 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}/method-rate-limits")
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept"] = "application/json"
request["x-api-key"] = "YOUR_API_KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "interval": "second",
  "methods": [
    "eth_getLogs"
  ],
  "rate": 10
})
response = https.request(request)
puts response.read_body
```

**Additional Example**

```bash
qn endpoint rate-limit method-create {endpoint_id} \
      --method eth_call \
      --interval second \
      --rate 25 \
      -o json
```

```javascript
import { QuicknodeSdk } from "@quicknode/sdk"
const qn = new QuicknodeSdk({ apiKey: "YOUR_API_KEY" })
const response = await qn.admin.createMethodRateLimit("ENDPOINT_ID", { interval: "second", methods: ["eth_blockNumber"], rate: 100 })
console.log(response)
```

```python
import asyncio
from quicknode_sdk import QuicknodeSdk, SdkFullConfig

async def main():
    qn = QuicknodeSdk(SdkFullConfig(api_key="YOUR_API_KEY"))
    response = await qn.admin.create_method_rate_limit("ENDPOINT_ID", interval="second", methods=["eth_blockNumber"], rate=100)
    print(response)

asyncio.run(main())
```

```rust
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").build())?;
    let response = qn.admin.create_method_rate_limit("ENDPOINT_ID", &Default::default()).await?;
    println!("{:?}", response);
    Ok(())
}
```