Rate Limit
You can process up to 500 images per minute through the API, depending on the input image resolution in megapixels.
Examples:
Input image
Megapixels
Effective Rate Limit
625 x 400
1
MP
500 images per minute
1200 x 800
1
MP
500 images per minute
1600 x 1200
2
MP
500 / 2 =
250 images per minute
2500 x 1600
4
MP
500 / 4 =
125 images per minute
4000 x 2500
10
MP
500 / 10 =
50 images per minute
6250 x 4000
25
MP
500 / 25 =
20 images per minute
8000 x 6250
50
MP
500 / 50 =
10 images per minute
Exceedance of rate limits leads to a HTTP status 429 response (no credits charged). Clients can use the following response headers to gracefully handle rate limits:
Response header
Sample value
Description
X-RateLimit-Limit
500
Total rate limit in megapixel images
X-RateLimit-Remaining
499
Remaining rate limit for this minute
X-RateLimit-Reset
1782330393
Unix timestamp when rate limit will reset
Retry-After
59
Seconds until rate limit will reset (only present if rate limit exceeded)
Higher rate limits are only available to high-volume solution users; get in touch here.
Sample Code
Handling Rate Limits in your code using the HTTP Retry-After header:
Rate Limit
cURL
Node.js
Python
Ruby
PHP
Java
.NET
Swift
Objective-C
#!/bin/bash
make_request_with_retry() {
while true; do
response=$(get_result)
status_code=$(echo "$response" | grep HTTP | awk '{print $2}')
if [ "$status_code" -eq 200 ]; then
echo "$response" | grep -v HTTP
return
elif [ "$status_code" -eq 429 ]; then
retry_after=$(echo "$response" | grep -i "Retry-After" | awk '{print $2}')
if [ -n "$retry_after" ]; then
echo "Rate limit reached. Retrying after $retry_after seconds..."
sleep "$retry_after"
else
echo "Rate limit reached. Retrying after a default delay..."
sleep 10 # Default fallback delay
fi
else
echo "Request failed with status code $status_code"
exit 1
fi
done
}
get_result() {
# Placeholder for actual API call logic
# Example
curl -i -s -X POST "https://api.remove.bg/v1.0/removebg" \
-H "Content-Type: application/json" \
-d '{"image_url":"https://www.remove.bg/example.jpg"}'
echo "HTTP/1.1 429 Too Many Requests"
echo "Retry-After: 5"
}
make_request_with_retry
async function makeRequestWithRetry() {
while (true) {
const response = await getResult();
if (response.status === 200) {
return await response.json();
} else if (response.status === 429) {
const retryAfter = response.headers.get("Retry-After");
if (retryAfter) {
console.log(`Rate limit reached. Retrying after ${retryAfter} seconds...`);
await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
} else {
console.log("Rate limit reached. Retrying after a default delay...");
await new Promise(resolve => setTimeout(resolve, 10000)); // Default fallback delay
}
} else {
throw new Error(`Request failed with status ${response.status}`);
}
}
}
async function getResult() {
// Placeholder for actual API call logic
}
import requests
import time
async def make_request_with_retry():
while True:
response = get_result()
if response.status_code == 200:
return response.json()
elif response.status_code == 429:
retry_after = response.headers.get("Retry-After")
if retry_after:
print(f"Rate limit reached. Retrying after {retry_after} seconds...")
time.sleep(int(retry_after))
else:
print("Rate limit reached. Retrying after a default delay...")
time.sleep(10) # Default fallback delay
else:
response.raise_for_status()
async def get_result():
# Placeholder for actual API call logic
pass
require 'net/http'
require 'json'
require 'async'
async def make_request_with_retry
loop do
response = get_result
case response.code.to_i
when 200
return JSON.parse(response.body)
when 429
retry_after = response['Retry-After']
if retry_after
puts "Rate limit reached. Retrying after #{retry_after} seconds..."
sleep retry_after.to_i
else
puts "Rate limit reached. Retrying after a default delay..."
sleep 10 # Default fallback delay
end
else
response.value # Raises an HTTP error if the response is not 2xx
end
end
end
async def get_result
# Placeholder for actual API call logic
uri = URI('https://api.remove.bg/v1.0/removebg')
Net::HTTP.get_response(uri)
end
function make_request_with_retry() {
while (true) {
$response = get_result();
if ($response->getStatusCode() == 200) {
return json_decode($response->getBody(), true);
} elseif ($response->getStatusCode() == 429) {
$retry_after = $response->getHeader('Retry-After');
if ($retry_after) {
echo "Rate limit reached. Retrying after {$retry_after[0]} seconds...\n";
sleep((int)$retry_after[0]);
} else {
echo "Rate limit reached. Retrying after a default delay...\n";
sleep(10); // Default fallback delay
}
} else {
throw new Exception("HTTP request failed with status code " . $response->getStatusCode());
}
}
}
function get_result() {
// Placeholder for actual API call logic
}
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.TimeUnit;
public class RateLimitExample {
public static void main(String[] args) {
try {
makeRequestWithRetry();
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
public static void makeRequestWithRetry() throws IOException, InterruptedException {
while (true) {
HttpURLConnection connection = getResult();
int statusCode = connection.getResponseCode();
if (statusCode == 200) {
// Handle successful response
break;
} else if (statusCode == 429) {
String retryAfter = connection.getHeaderField("Retry-After");
if (retryAfter != null) {
System.out.println("Rate limit reached. Retrying after " + retryAfter + " seconds...");
TimeUnit.SECONDS.sleep(Integer.parseInt(retryAfter));
} else {
System.out.println("Rate limit reached. Retrying after a default delay...");
TimeUnit.SECONDS.sleep(10); // Default fallback delay
}
} else {
throw new IOException("Unexpected response code: " + statusCode);
}
}
}
public static HttpURLConnection getResult() throws IOException {
// Placeholder for actual API call logic
URL url = new URL("https://api.remove.bg/v1.0/removebg");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Type", "application/json");
connection.setDoOutput(true);
String jsonInputString = "{\"image_url\":\"https://www.remove.bg/example.jpg\"}";
try (OutputStream os = connection.getOutputStream()) {
byte[] input = jsonInputString.getBytes("utf-8");
os.write(input, 0, input.length);
}
return connection;
}
}
#import
@interface RateLimiter : NSObject
- (void)makeRequestWithRetry;
@end
@implementation RateLimiter
- (void)makeRequestWithRetry {
while (YES) {
NSDictionary *response = [self getResult];
NSInteger statusCode = [response[@"statusCode"] integerValue];
if (statusCode == 200) {
NSLog(@"%@", response[@"data"]);
return;
} else if (statusCode == 429) {
NSString *retryAfter = response[@"headers"][@"Retry-After"];
if (retryAfter) {
NSLog(@"Rate limit reached. Retrying after %@ seconds...", retryAfter);
[NSThread sleepForTimeInterval:[retryAfter intValue]];
} else {
NSLog(@"Rate limit reached. Retrying after a default delay...");
[NSThread sleepForTimeInterval:10];
}
} else {
[NSException raise:@"RequestFailed" format:@"Request failed with status code: %ld", (long)statusCode];
}
}
}
- (NSDictionary *)getResult {
// Placeholder for actual API call logic
return @{};
}
@end
import Foundation
import FoundationNetworking
func makeRequestWithRetry(completion: @escaping (Result<>) -> Void) {
var requestBody = [
"image_url": "https://www.remove.bg/example.jpg"
]
let url = URL(string: "https://api.remove.bg/v1.0/removebg")!
var request = URLRequest(url: url)
request.httpBody = try? JSONSerialization.data(withJSONObject: requestBody, options: [])
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
func executeRequest() {
let task = URLSession.shared.dataTask(with: request) { responseData, response, error in
if let error = error {
completion(.failure(error))
return
}
guard let httpResponse = response as? HTTPURLResponse else {
completion(.failure(NSError(domain: "InvalidResponse", code: 0, userInfo: nil)))
return
}
switch httpResponse.statusCode {
case 200:
if let responseData = responseData {
completion(.success(responseData))
} else {
completion(.failure(NSError(domain: "NoData", code: 0, userInfo: nil)))
}
case 429:
if let retryAfter = httpResponse.allHeaderFields["Retry-After"] as? String, let retryAfterSeconds = Double(retryAfter) {
print("Rate limit reached. Retrying after \(retryAfterSeconds) seconds...")
DispatchQueue.global().asyncAfter(deadline: .now() + retryAfterSeconds) {
executeRequest()
}
} else {
print("Rate limit reached. Retrying after a default delay...")
DispatchQueue.global().asyncAfter(deadline: .now() + 10) {
executeRequest()
}
}
default:
completion(.failure(NSError(domain: "HTTPError", code: httpResponse.statusCode, userInfo: nil)))
}
}
task.resume()
}
executeRequest()
}
using System;
using System.Net.Http;
using System.Threading.Tasks;
public class RateLimitExample
{
private static readonly HttpClient client = new HttpClient();
public static async Task Main(string[] args)
{
var result = await MakeRequestWithRetry();
Console.WriteLine(result);
}
private static async Task MakeRequestWithRetry()
{
while (true)
{
var response = await GetResult();
if (response.IsSuccessStatusCode)
{
return await response.Content.ReadAsStringAsync();
}
else if (response.StatusCode == (System.Net.HttpStatusCode)429)
{
if (response.Headers.TryGetValues("Retry-After", out var values))
{
var retryAfter = int.Parse(values.First());
Console.WriteLine($"Rate limit reached. Retrying after {retryAfter} seconds...");
await Task.Delay(retryAfter * 1000);
}
else
{
Console.WriteLine("Rate limit reached. Retrying after a default delay...");
await Task.Delay(10000); // Default fallback delay
}
}
else
{
response.EnsureSuccessStatusCode();
}
}
}
private static async Task GetResult()
{
// Placeholder for actual API call logic
var content = new StringContent("{\"image_url\":\"https://www.remove.bg/example.jpg\"}", System.Text.Encoding.UTF8, "application/json");
return await client.PostAsync("https://api.remove.bg/v1.0/removebg", content);
}
}
Was this section helpful?
Yes
No
Send Feedback
Thanks for your feedback.