RPDB API | ApiDoc

API Keys

In order to use the RPDB API you must first subscribe to one of the Tiers on Patreon.

Upon subscribing the API Key will be received by e-mail.

API URL

The API should always be accessed over SSL.

https://api.ratingposterdb.com

Request Limits

Each Tier has a monthly request limit, upon passing the request limit the service will respond with an error.

Caching of images is allowed for personal use and recommended for larger projects.

Tier	Request Limit
1	50,000
2	100,000
3	150,000
4	750,000

Detecting API Key Tier

The tier of each API Key can be derived from the API Key itself from the first 2 characters.

Tier	API Key Starts With
1	t1-...
2	t2-...
3	t3-...
4	t4-...

Supported IDs

RPDB supports the following Metadata IDs:

IMDB (example: tt0944947)
TMDB (needs to be prefixed by movie- or series-, example: series-225171)
TVDB (needs to be prefixed by movie- or series-, example: movie-190)

Stremio Addons

Implementing RPDB with Stremio addons is easy, the image URL should be changed to the following:

poster: https://api.ratingposterdb.com/{userApiKey}/{mediaType}/poster-default/{mediaId}.jpg
logo: https://api.ratingposterdb.com/{userApiKey}/{mediaType}/logo-default/{mediaId}.png
backdrop: https://api.ratingposterdb.com/{userApiKey}/{mediaType}/backdrop-default/{mediaId}.jpg

Where the values are:

userApiKey: the user's RPDB API Key
mediaType: can be either imdb, tmdb or tvdb
mediaId: the Metadata ID (from IMDB, TMDB or TVDB) as explained in the "Supported IDs" section

Note: We highly recommend using ?fallback=true for images in Stremio addons, this will make the posters fallback to a normal poster (without ratings) if an item is currently missing ratings.

There is nothing else required to implement RPDB in Stremio addons except changing the image URL as explained above. Users can then change all aspects of their RPDB images by visiting https://manager.ratingposterdb.com/ separately and all RPDB images will reflect their chosen settings.

Validating API Keys

If the API Key is valid it will return a 200 status code along with a JSON body.

If it is invalid, it will return a 403 status code along with a text response.

GET Example

/{apiKey}/isValid

Parameters

Name	Type	Description
apiKey required	string	The user's API Key

Responses

200 application/json

{
    "valid": true
}

403 text/plain

API Key is Invalid

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/isValid'

fetch("https://api.ratingposterdb.com/{apiKey}/isValid", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/isValid",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/isValid"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/isValid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/isValid")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/isValid"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/isValid"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/isValid");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/isValid HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/isValid 📋

Parameters

apiKey * (string)

The user's API Key

Headers

Response Type

Response Headers

Response Body

Checking API Key Request Count

This action responds with the current request count and Tier request limit.

GET Example

/{apiKey}/requests

Parameters

Name	Type	Description
apiKey required	string	The user's API Key

Response

200 application/json

{
    "req": 1502,
    "limit": 20000
}

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/requests'

fetch("https://api.ratingposterdb.com/{apiKey}/requests", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/requests",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/requests"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/requests",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/requests")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/requests"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/requests"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/requests");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/requests HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/requests 📋

Parameters

apiKey * (string)

The user's API Key

Headers

Response Type

Response Headers

Response Body

Posters with Ratings

Tier 0 only supports poster-default, all other tiers support all 4 poster types.

Poster types starting with textless- will prefer the textless versions of the posters (if available).

Examples:

Note: For anime, this endpoint will also reply with MAL rating, for details check the "Anime Ratings" category of this page.

Note 2: Adding ?fallback=true to the querystring will make the API return a normal poster in case ratings are missing, otherwise the API will reply with an error in such a case.

GET Example

/{apiKey}/{idType}/{posterType}/{mediaId}.jpg

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
posterType required	string	The poster rating type, can be: `poster-default`, `poster-certs`, `poster-mc`, `poster-rt`, `textless-default`, `textless-certs`, `textless-mc`, `textless-rt`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-default/tt2395427.jpg",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-default/tt2395427.jpg HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

posterType * (string)

The poster rating type, can be: poster-default, poster-certs, poster-mc, poster-rt, textless-default, textless-certs, textless-mc, textless-rt

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

Headers

Response Type

Response Headers

Response Body

Localized Posters with Ratings Tier 1+

You can use the ?lang= query parameter with any ISO 639-1 code to prefer posters in a particular language.

In addition to ISO 639-1 two letter language code, the following language codes are also supported to cover regional language variation:

"pt-PT" - Portuguese (Portugal)
"pt-BR" - Portuguese (Brazil)
"es-ES" - Spanish (Spain)
"es-MX" - Spanish (Mexico)
"zh-CN" - Chinese (Mainland China)
"zh-HK" - Chinese (Hong Kong)
"zh-SG" - Chinese (Singapore)
"zh-TW" - Chinese (Taiwan)

GET Example

/{apiKey}/{idType}/{posterType}/{mediaId}.jpg?lang={lang}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
posterType required	string	The poster rating type, can be: `poster-default`, `poster-certs`, `poster-mc`, `poster-rt`, `textless-default`, `textless-certs`, `textless-mc`, `textless-rt`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
lang required	string	Poster language in ISO 639-1 (2 letter language code)

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?lang=en'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?lang=en", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-default/tt2395427.jpg?lang=en",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?lang=en"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?lang=en",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?lang=en")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?lang=en"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?lang=en"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?lang=en");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-default/tt2395427.jpg?lang=en HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?lang=en 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

posterType * (string)

The poster rating type, can be: poster-default, poster-certs, poster-mc, poster-rt, textless-default, textless-certs, textless-mc, textless-rt

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

lang * (string)

Poster language in ISO 639-1 (2 letter language code)

Headers

Response Type

Response Headers

Response Body

Themes

You can set the theme of a poster by setting the ?theme= option.

Available themes:

"bar": dark rating bar (bottom) [Tier 0+]
"blocks": dark blocks (bottom) [Tier 0+]
"rounded-blocks": dark rounded blocks (bottom) [Tier 0+]
"boxes": dark boxes (bottom) [Tier 0+]
"sharp-blocks": dark sharp blocks (bottom) [Tier 1+]
"stripes-right": dark stripes skewed to the right (bottom) [Tier 1+]
"stripes-left": dark stripes skewed to the left (bottom) [Tier 1+]
"light-bar": light rating bar (bottom) [Tier 1+]
"light-blocks": light blocks (bottom) [Tier 1+]
"light-rounded-blocks": light rounded blocks (bottom) [Tier 1+]
"light-boxes": light boxes (bottom) [Tier 1+]
"light-sharp-blocks": light sharp blocks (bottom) [Tier 1+]
"light-stripes-right": light stripes skewed to the right (bottom) [Tier 1+]
"light-stripes-left": light stripes skewed to the left (bottom) [Tier 1+]

Themes can be edited with ?ratingBarPos to change the rating bar position, ?fontScale to change the font size and any of the other styling options.

GET Example

/{apiKey}/{idType}/{posterType}/{mediaId}.jpg?theme={theme}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
posterType required	string	The poster rating type, can be: `poster-default`, `poster-certs`, `poster-mc`, `poster-rt`, `textless-default`, `textless-certs`, `textless-mc`, `textless-rt`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
theme required	string	Poster theme name

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?theme=default'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?theme=default", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-default/tt2395427.jpg?theme=default",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?theme=default"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?theme=default",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?theme=default")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?theme=default"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?theme=default"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?theme=default");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-default/tt2395427.jpg?theme=default HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?theme=default 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

posterType * (string)

The poster rating type, can be: poster-default, poster-certs, poster-mc, poster-rt, textless-default, textless-certs, textless-mc, textless-rt

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

theme * (string)

Poster theme name

Headers

Response Type

Response Headers

Response Body

Labels Tier 2+

To add a label with custom text to a poster, you can add ?label= followed by the URL encoded label text.

See Poster Example

GET Example

/{apiKey}/{idType}/{posterType}/{mediaId}.jpg?label={label}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
posterType required	string	The poster rating type, can be: `poster-default`, `poster-certs`, `poster-mc`, `poster-rt`, `textless-default`, `textless-certs`, `textless-mc`, `textless-rt`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
label required	string	Custom text to set as poster label

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?label=custom text'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?label=custom text", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-default/tt2395427.jpg?label=custom text",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?label=custom text"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?label=custom text",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?label=custom text")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?label=custom text"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?label=custom text"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?label=custom text");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-default/tt2395427.jpg?label=custom text HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?label=custom text 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

posterType * (string)

The poster rating type, can be: poster-default, poster-certs, poster-mc, poster-rt, textless-default, textless-certs, textless-mc, textless-rt

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

label * (string)

Custom text to set as poster label

Headers

Response Type

Response Headers

Response Body

Badges Tier 2+

To add a badges to a poster, you can add ?badges= followed by a list of badge tags.

Badge tags should be separated by ,.

A poster can have a maximum of 4 badges at one time, if more badges are set only the first 4 will show.

In addition to the badge tags below, you can also use 2 letter country codes prefixed by country. to show country flags as badges. Example: ?badges=country.de (to show the flag of Germany)

Dynamic badges:

Tag	Type	Title	Subtitle	Color
commonsense	age rating	known age rating	Common Sense	Silver
commonsensegold	age rating	known age rating	Common Sense	Gold
age_rating	age rating	known age rating	Common Sense	Silver
age_rating_gold	age rating	known age rating	Common Sense	Gold
us_age_rating	age rating	US age rating	Common Sense	Silver
us_age_rating_gold	age rating	US age rating	Common Sense	Gold
auto_resolution	video quality	highest known video resolution	Varied	Bronze/Silver/Gold
auto_dv_hdr	color range	highest known release	Varied	Gold/Multicolor
auto_lang	flag by spoken language	country flag	none	none
auto_lang_no_en	flag by spoken language (ignores EN)	country flag	none	none
auto_country	flag by production country	country flag	none	none
auto_country_no_us	flag by production country (ignores US)	country flag	none	none

Supported badge tags:

Tag	Type	Title	Subtitle	Color
4k	video quality	4K	Ultra HD	Gold
4kupscaled	video quality	4K	Upscaled	Silver
1080p	video quality	1080p	Full HD	Gold
720p	video quality	720p	HD	Silver
720pgold	video quality	720p	HD	Gold
2k	video quality	2K	Quad HD	Gold
5k	video quality	5K	Ultra HD	Gold
8k	video quality	8K	Ultra HD	Gold
576p	video quality	576p	SD	Bronze
480p	video quality	480p	SD	Bronze
360p	video quality	360p	SD	Bronze
240p	video quality	240p	SD	Bronze
hd	video quality	HD	Medium Quality	Silver
sd	video quality	SD	Low Quality	Bronze
3d	video type	3D	Stereoscopic	Gold
hdrcolor	color range	HDR	True Color	Multicolor
hdr	color range	HDR	True Color	Silver
hdr10plus	color range	HDR10+	True Color	Silver
hdr10plus_colorful	color range	HDR10+	Multicolor	Silver
dolbyvision	color range	(icon)	Dolby Vision	Multicolor
dolbyvisioncolor	color range	(icon)	Dolby Vision [alt 1]	Multicolor
dolbyvisioncoloralt	color range	(icon)	Dolby Vision [alt 2]	Multicolor
dv_hdr_gold	color range	DV/HDR	True Color	Gold
dv_hdr_colorful	color range	DV/HDR	True Color	Multicolor
hybrid_gold	color range	HYBRID	True Color	Gold
hybrid_colorful	color range	HYBRID	True Color	Multicolor
imaxgold	aspect ratio	IMAX	Widescreen	Gold
imax	aspect ratio	IMAX	Widescreen	Silver
remuxgold	video source	REMUX	Lossless	Gold
remux	video source	REMUX	Lossless	Silver
bluray	video source	BluRay	Format	Silver
dvd	video source	DVD	Format	Silver
web	video source	WEB	Format	Silver
mkv	video container	MKV	Matroska	Silver
mp4	video container	MP4	MPEG-4	Silver
avi	video container	AVI	A/V Interleave	Silver
h264	video encoding	h264	AVC	Silver
h265	video encoding	h265	HEVC	Silver
h266	video encoding	h266	VVC	Silver
audio20	audio	2.0	Stereo	Silver
audio51	audio	5.1	Surround	Silver
audio71	audio	7.1	Surround	Silver
dd20	audio	DD2.0	Stereo	Silver
dd51	audio	DD5.1	Surround	Silver
ddp20	audio	DDP2.0	Stereo	Silver
ddp51	audio	DDP5.1	Surround	Silver
ddp71	audio	DDP7.1	Surround	Silver
truehd51lossless	audio	TrueHD5.1	Lossless	Silver
truehd51surround	audio	TrueHD5.1	Surround	Silver
truehd71lossless	audio	TrueHD7.1	Lossless	Silver
truehd71surround	audio	TrueHD7.1	Surround	Silver
pcm51lossless	audio	PCM5.1	Lossless	Silver
pcm51surround	audio	PCM5.1	Surround	Silver
pcm71lossless	audio	PCM7.1	Lossless	Silver
pcm71surround	audio	PCM7.1	Surround	Silver
atmos3dsound	audio	Atmos	3D Sound	Silver
atmossurround	audio	Atmos	Surround	Silver
5stars	personal rating	5 ✯	Perfect	Gold
4stars	personal rating	4 ✯	Great	Silver
3stars	personal rating	3 ✯	Good	Silver
2stars	personal rating	2 ✯	Bad	Bronze
1stars	personal rating	1 ✯	Horrible	Bronze
cannesnominee	awards	NOMINEE	CANNES	Silver
canneswinner	awards	WINNER	CANNES	Gold
criterion	awards	(icon)	CRITERION	Gold
emmynominee	awards	NOMINEE	EMMYS	Silver
emmywinner	awards	WINNER	EMMYS	Gold
goldenglobesnominee	awards	NOMINEE	GOLDEN GLOBES	Silver
goldenglobeswinner	awards	WINNER	GOLDEN GLOBES	Gold
mastersofthecinema	awards	(icon)	CLASSICS	Gold
oscarsnominee	awards	NOMINEE	OSCARS	Silver
oscarswinner	awards	WINNER	OSCARS	Gold
sundancenominee	awards	NOMINEE	SUNDANCE	Silver
sundancewinner	awards	WINNER	SUNDANCE	Gold
sundancewinner	awards	WINNER	SUNDANCE	Gold
directorscut	special edition	DIRECTOR'S CUT	SPECIAL EDITION	Gold
extendedcut	special edition	EXTENDED CUT	SPECIAL EDITION	Gold
g	age rating	G	CERTIFICATION	Silver
g_gold	age rating	G	CERTIFICATION	Gold
nc_17	age rating	NC-17	CERTIFICATION	Silver
nc_17_gold	age rating	NC-17	CERTIFICATION	Gold
nr	age rating	NR	CERTIFICATION	Silver
nr_gold	age rating	NR	CERTIFICATION	Gold
pg_13	age rating	PG-13	CERTIFICATION	Silver
pg_13_gold	age rating	PG-13	CERTIFICATION	Gold
pg	age rating	PG	CERTIFICATION	Silver
pg_gold	age rating	PG	CERTIFICATION	Gold
r	age rating	R	CERTIFICATION	Silver
r_gold	age rating	R	CERTIFICATION	Gold
tv_14	age rating	TV-14	CERTIFICATION	Silver
tv_14_gold	age rating	TV-14	CERTIFICATION	Gold
tv_g	age rating	TV-G	CERTIFICATION	Silver
tv_g_gold	age rating	TV-G	CERTIFICATION	Gold
tv_ma	age rating	TV-MA	CERTIFICATION	Silver
tv_ma_gold	age rating	TV-MA	CERTIFICATION	Gold
tv_pg	age rating	TV-PG	CERTIFICATION	Silver
tv_pg_gold	age rating	TV-PG	CERTIFICATION	Gold
tv_y	age rating	TV-Y	CERTIFICATION	Silver
tv_y_gold	age rating	TV-Y	CERTIFICATION	Gold
tv_y7	age rating	TV-Y7	CERTIFICATION	Silver
tv_y7_gold	age rating	TV-Y7	CERTIFICATION	Gold
age(2..18)	age rating	age (2..18)+	COMMON SENSE	Silver
age(2..18)gold	age rating	age (2..18)+	COMMON SENSE	Gold

See Poster Example

GET Example

/{apiKey}/{idType}/{posterType}/{mediaId}.jpg?badges={badges}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
posterType required	string	The poster rating type, can be: `poster-default`, `poster-certs`, `poster-mc`, `poster-rt`, `textless-default`, `textless-certs`, `textless-mc`, `textless-rt`
mediaId required	string	The ID for the movie / series, depending on the chosen `id-type`
badges required	string	Badge tags separated by , (comma)

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

posterType * (string)

The poster rating type, can be: poster-default, poster-certs, poster-mc, poster-rt, textless-default, textless-certs, textless-mc, textless-rt

mediaId * (string)

The ID for the movie / series, depending on the chosen id-type

badges * (string)

Badge tags separated by , (comma)

Headers

Response Type

Response Headers

Response Body

Maximum Number of Badges Tier 3+

The maximum number of badges to show at once on an image, the default value for this differs based on rating bar position and image type.

The value is expected to be a number, example: 1, 2, 3, 4, etc

GET Example

/{apiKey}/{idType}/{posterType}/{mediaId}.jpg?badges={badges}&maxBadges={maxBadges}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
posterType required	string	The poster rating type, can be: `poster-default`, `poster-certs`, `poster-mc`, `poster-rt`, `textless-default`, `textless-certs`, `textless-mc`, `textless-rt`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
badges required	string	Badge tags separated by , (comma)
maxBadges required	string	Maximum badges, can be: `1`, `2`, `3`, `4`, etc

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&maxBadges=2'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&maxBadges=2", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&maxBadges=2",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&maxBadges=2"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&maxBadges=2",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&maxBadges=2")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&maxBadges=2"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&maxBadges=2"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&maxBadges=2");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&maxBadges=2 HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&maxBadges=2 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

posterType * (string)

The poster rating type, can be: poster-default, poster-certs, poster-mc, poster-rt, textless-default, textless-certs, textless-mc, textless-rt

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

badges * (string)

Badge tags separated by , (comma)

maxBadges * (string)

Maximum badges, can be: 1, 2, 3, 4, etc

Headers

Response Type

Response Headers

Response Body

Badge Position Tier 3+

The badge position can be set with the ?badgePos= query parameter and works for both posters and backdrops.

Supported badge positions: left (default), center, right, bottom|left, bottom|center, bottom|right

Example for Left Badges

Example for Center Badges

Example for Right Badges

GET Example

/{apiKey}/{idType}/{posterType}/{mediaId}.jpg?badges={badges}&badgePos={badgePos}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
posterType required	string	The poster rating type, can be: `poster-default`, `poster-certs`, `poster-mc`, `poster-rt`, `textless-default`, `textless-certs`, `textless-mc`, `textless-rt`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
badges required	string	Badge tags separated by , (comma)
badgePos required	string	Badge position, can be: `left` (default), `center`, `right`

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&badgePos=center'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&badgePos=center", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&badgePos=center",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&badgePos=center"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&badgePos=center",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&badgePos=center")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&badgePos=center"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&badgePos=center"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&badgePos=center");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&badgePos=center HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tt2395427.jpg?badges=4k&badgePos=center 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

posterType * (string)

The poster rating type, can be: poster-default, poster-certs, poster-mc, poster-rt, textless-default, textless-certs, textless-mc, textless-rt

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

badges * (string)

Badge tags separated by , (comma)

badgePos * (string)

Badge position, can be: left (default), center, right

Headers

Response Type

Response Headers

Response Body

TMDB Poster Choices Tier 2+

GET Example

/{apiKey}/{idType}/{posterType}/tmdb-poster/{mediaId}/{tmdbPosterFilename}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
posterType required	string	The poster rating type, can be: `poster-default`, `poster-certs`, `poster-mc`, `poster-rt`, `textless-default`, `textless-certs`, `textless-mc`, `textless-rt`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
tmdbPosterFilename required	string	The image filename from the TMDB Poster Image Response

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tmdb-poster/tt2395427/kqjL17yufvn9OVLyXYpvtyrFfak.jpg'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tmdb-poster/tt2395427/kqjL17yufvn9OVLyXYpvtyrFfak.jpg", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-default/tmdb-poster/tt2395427/kqjL17yufvn9OVLyXYpvtyrFfak.jpg",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tmdb-poster/tt2395427/kqjL17yufvn9OVLyXYpvtyrFfak.jpg"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tmdb-poster/tt2395427/kqjL17yufvn9OVLyXYpvtyrFfak.jpg",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tmdb-poster/tt2395427/kqjL17yufvn9OVLyXYpvtyrFfak.jpg")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tmdb-poster/tt2395427/kqjL17yufvn9OVLyXYpvtyrFfak.jpg"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tmdb-poster/tt2395427/kqjL17yufvn9OVLyXYpvtyrFfak.jpg"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tmdb-poster/tt2395427/kqjL17yufvn9OVLyXYpvtyrFfak.jpg");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-default/tmdb-poster/tt2395427/kqjL17yufvn9OVLyXYpvtyrFfak.jpg HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/tmdb-poster/tt2395427/kqjL17yufvn9OVLyXYpvtyrFfak.jpg 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

posterType * (string)

The poster rating type, can be: poster-default, poster-certs, poster-mc, poster-rt, textless-default, textless-certs, textless-mc, textless-rt

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

tmdbPosterFilename * (string)

The image filename from the TMDB Poster Image Response

Headers

Response Type

Response Headers

Response Body

Custom Poster Images Tier 3+

The ?img= query parameter needs to be set to an image URI (URL encoded).

GET Example

/{apiKey}/{idType}/{posterType}/custom-poster/{mediaId}.jpg?img={img}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
posterType required	string	The poster rating type, can be: `poster-default`, `poster-certs`, `poster-mc`, `poster-rt`, `textless-default`, `textless-certs`, `textless-mc`, `textless-rt`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
img required	string	Any image URI to use as poster

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/custom-poster/tt2395427.jpg?img=https://image.tmdb.org/t/p/w780/RYMX2wcKCBAr24UyPD7xwmjaTn.jpg'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/custom-poster/tt2395427.jpg?img=https://image.tmdb.org/t/p/w780/RYMX2wcKCBAr24UyPD7xwmjaTn.jpg", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-default/custom-poster/tt2395427.jpg?img=https://image.tmdb.org/t/p/w780/RYMX2wcKCBAr24UyPD7xwmjaTn.jpg",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/custom-poster/tt2395427.jpg?img=https://image.tmdb.org/t/p/w780/RYMX2wcKCBAr24UyPD7xwmjaTn.jpg"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/custom-poster/tt2395427.jpg?img=https://image.tmdb.org/t/p/w780/RYMX2wcKCBAr24UyPD7xwmjaTn.jpg",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/custom-poster/tt2395427.jpg?img=https://image.tmdb.org/t/p/w780/RYMX2wcKCBAr24UyPD7xwmjaTn.jpg")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/custom-poster/tt2395427.jpg?img=https://image.tmdb.org/t/p/w780/RYMX2wcKCBAr24UyPD7xwmjaTn.jpg"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/custom-poster/tt2395427.jpg?img=https://image.tmdb.org/t/p/w780/RYMX2wcKCBAr24UyPD7xwmjaTn.jpg"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/custom-poster/tt2395427.jpg?img=https://image.tmdb.org/t/p/w780/RYMX2wcKCBAr24UyPD7xwmjaTn.jpg");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-default/custom-poster/tt2395427.jpg?img=https://image.tmdb.org/t/p/w780/RYMX2wcKCBAr24UyPD7xwmjaTn.jpg HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-default/custom-poster/tt2395427.jpg?img=https://image.tmdb.org/t/p/w780/RYMX2wcKCBAr24UyPD7xwmjaTn.jpg

📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

posterType * (string)

The poster rating type, can be: poster-default, poster-certs, poster-mc, poster-rt, textless-default, textless-certs, textless-mc, textless-rt

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

img * (string)

Any image URI to use as poster

Headers

Response Type

Response Headers

Response Body

Backdrops with Ratings Tier 2+

Example of Backdrop

Note: as with posters, backdrops also support custom ratings choice, rating order, as well as all Tier 3 customisation such as choosing where the ratings are shown and the color of the rating background and text color.

GET Example

/{apiKey}/{idType}/{backdropType}/{mediaId}.jpg

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
backdropType required	string	The backdrop type, currently only `backdrop-default` is supported
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/backdrop-default/tt2395427.jpg",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/backdrop-default/tt2395427.jpg HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

backdropType * (string)

The backdrop type, currently only backdrop-default is supported

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

Headers

Response Type

Response Headers

Response Body

Logos with Ratings Tier 2+

Note: compared to posters and backdrops which are JPG, it is important to note that logos are PNG images as they require transparency.

Note 2: due to limited space in the logo image, logos do not support badges

Note 3: as with posters, logos also support custom ratings choice, rating order, as well as all Tier 3 customisation such as choosing where the ratings are shown and the color of the rating background and text color.

Example of Logo

GET Example

/{apiKey}/{idType}/{logoType}/{mediaId}.png

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
logoType required	string	The logo type, currently only `logo-default` is supported
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)

Response

200 image/png

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/logo-default/tt2395427.png'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/logo-default/tt2395427.png", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/logo-default/tt2395427.png",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/logo-default/tt2395427.png"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/logo-default/tt2395427.png",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/logo-default/tt2395427.png")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/logo-default/tt2395427.png"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/logo-default/tt2395427.png"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/logo-default/tt2395427.png");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/logo-default/tt2395427.png HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/logo-default/tt2395427.png 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

logoType * (string)

The logo type, currently only logo-default is supported

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

Headers

Response Type

Response Headers

Response Body

Anime Ratings

All known anime movies and series include MAL rating by default (except for the free tier), so the API is the same as in the "Posters with Ratings" category of this page.

In the case of anime, instead of receiving IMDB + RT + MC ratings, you will receive MAL + IMDB + RT (+ MC if any other rating is missing) with the following poster types: poster-default, poster-certs, poster-rt, poster-mc, backdrop-default, textless-default, textless-certs, textless-rt, textless-mc.

This applies for all Tiers.

GET Example

/{apikey}/{idType}/{posterType}/{mediaId}.jpg

Parameters

Name	Type	Description
apikey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
posterType required	string	The poster rating type, can be: `poster-default`, `poster-certs`, `poster-mc`, `poster-rt`, `textless-default`, `textless-certs`, `textless-mc`, `textless-rt`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apikey}/imdb/poster-default/tt2395427.jpg'

fetch("https://api.ratingposterdb.com/{apikey}/imdb/poster-default/tt2395427.jpg", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apikey}/imdb/poster-default/tt2395427.jpg",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apikey}/imdb/poster-default/tt2395427.jpg"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apikey}/imdb/poster-default/tt2395427.jpg",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apikey}/imdb/poster-default/tt2395427.jpg")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apikey}/imdb/poster-default/tt2395427.jpg"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apikey}/imdb/poster-default/tt2395427.jpg"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apikey}/imdb/poster-default/tt2395427.jpg");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apikey}/imdb/poster-default/tt2395427.jpg HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apikey}/imdb/poster-default/tt2395427.jpg 📋

Parameters

apikey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

posterType * (string)

The poster rating type, can be: poster-default, poster-certs, poster-mc, poster-rt, textless-default, textless-certs, textless-mc, textless-rt

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

Headers

Response Type

Response Headers

Response Body

More Ratings Tier 1+

The ?order= query parameter needs to be set to a text that includes one or more rating tags, split by comma. This querystring parameter works with rating-order image type for posters, backdrop-default image type for backdrops and logo-default image type for logos.

Example order query parameter values:

myanimelist,imdb,commonsense,letterboxd
imdb,tmdb,trakt

Currently available rating tags:

imdb : IMDB audience rating
tmdb : TMDB audience rating
trakt : Trakt audience rating
tomatoes-critics : Rotten Tomaotes critics rating
tomatoes-audience : Rotten Tomaotes audience rating
metacritic-critics : Metacritic critics rating
metacritic-audience : Metacritic audience rating
letterboxd : Letterboxd audience rating
rogerebert : Roger Ebert rating
myanimelist : MyAnimeList audience rating
commonsense : Common Sense Media age rating
mdblist : MDBList rating
us-age : US age rating
overall-rating : overall rating (based on all audience and critics scores)
critics-rating : overall critics rating (based on all critics scores)
audience-rating : overall audience rating (based on all audience scores)

GET Example

/{apiKey}/{idType}/{imageType}/{mediaId}.jpg?order={order}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
imageType required	string	For posters use `rating-order`, for backdrops use `backdrop-default`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
order required	string	Text including one or more rating tags

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/rating-order/tt2395427.jpg?order=myanimelist'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/rating-order/tt2395427.jpg?order=myanimelist", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/rating-order/tt2395427.jpg?order=myanimelist",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/rating-order/tt2395427.jpg?order=myanimelist"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/rating-order/tt2395427.jpg?order=myanimelist",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/rating-order/tt2395427.jpg?order=myanimelist")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/rating-order/tt2395427.jpg?order=myanimelist"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/rating-order/tt2395427.jpg?order=myanimelist"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/rating-order/tt2395427.jpg?order=myanimelist");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/rating-order/tt2395427.jpg?order=myanimelist HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/rating-order/tt2395427.jpg?order=myanimelist 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

imageType * (string)

For posters use rating-order, for backdrops use backdrop-default

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

order * (string)

Text including one or more rating tags

Headers

Response Type

Response Headers

Response Body

Image Size Tier 2+

Poster image sizes:

medium: 580x859 (default)
large: 1280x1896 (Tier 2+)
verylarge: 2000x2962 (Tier 3+)

Backdrop image sizes:

medium: 1920x1080 (default)
small: 1280x720 (Tier 2+)
large: 3840x2160 (Tier 3+)

Logo image sizes:

medium: 780x244 (default)
large: 1722x539 (Tier 2+)
verylarge: 2689x841 (Tier 3+)

GET Example

/{apiKey}/{idType}/poster-certs/{mediaId}.jpg?imageSize={imageSize}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
imageSize required	string	Text including preferred image size

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?imageSize=large'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?imageSize=large", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-certs/tt2395427.jpg?imageSize=large",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?imageSize=large"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?imageSize=large",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?imageSize=large")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?imageSize=large"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?imageSize=large"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?imageSize=large");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-certs/tt2395427.jpg?imageSize=large HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?imageSize=large 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

imageSize * (string)

Text including preferred image size

Headers

Response Type

Response Headers

Response Body

Font Size Tier 2+

Supported values:

1 (default)
1.1
1.2
1.3
1.4
1.5

GET Example

/{apiKey}/{idType}/poster-certs/{mediaId}.jpg?fontScale={fontScale}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
fontScale required	string	Font size

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontScale=1'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontScale=1", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontScale=1",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontScale=1"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontScale=1",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontScale=1")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontScale=1"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontScale=1"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontScale=1");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-certs/tt2395427.jpg?fontScale=1 HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontScale=1 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

fontScale * (string)

Font size

Headers

Response Type

Response Headers

Response Body

Font Weight Tier 2+

Supported values:

0 - Normal (default)
1 - Bold

GET Example

/{apiKey}/{idType}/poster-certs/{mediaId}.jpg?fontWeight={fontWeight}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
fontWeight required	string	Font weight

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontWeight=1'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontWeight=1", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontWeight=1",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontWeight=1"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontWeight=1",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontWeight=1")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontWeight=1"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontWeight=1"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontWeight=1");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-certs/tt2395427.jpg?fontWeight=1 HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontWeight=1 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

fontWeight * (string)

Font weight

Headers

Response Type

Response Headers

Response Body

Font Style Tier 2+

Supported values:

0 : Default, will show ratings in the form of: 7.4/10, 75%, 2/5, etc
1 : Normalizes ratings to all be between 1-100 and removes "/5", "/10", "%" suffix, examples: 75, 12, 39
2 : Only remove "/5" and "/10" suffix, examples: 7.4, 75%, 2.2, etc

GET Example

/{apiKey}/{idType}/poster-certs/{mediaId}.jpg?textStyle={textStyle}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
textStyle required	string	Font Style, can be: `0`, `1`, `2`

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?textStyle=1'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?textStyle=1", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-certs/tt2395427.jpg?textStyle=1",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?textStyle=1"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?textStyle=1",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?textStyle=1")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?textStyle=1"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?textStyle=1"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?textStyle=1");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-certs/tt2395427.jpg?textStyle=1 HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?textStyle=1 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

textStyle * (string)

Font Style, can be: 0, 1, 2

Headers

Response Type

Response Headers

Response Body

Rating Bar Position Tier 3+

Poster image rating bar positions:

bottom (default)
top
left-top
left-center
left-bottom
right-top
right-center
right-bottom

Backdrop image rating bar positions:

right-top (default)
right-center
right-bottom
left-top
left-center
left-bottom

Logo image rating bar positions:

bottom (default)
top
left-top
left-center
left-bottom
right-top
right-center
right-bottom
bottom-left
bottom-right
top-left
top-right

GET Example

/{apiKey}/{idType}/poster-certs/{mediaId}.jpg?ratingBarPos={ratingBarPos}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
ratingBarPos required	string	Text including preferred rating bar position

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPos=top'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPos=top", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPos=top",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPos=top"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPos=top",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPos=top")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPos=top"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPos=top"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPos=top");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPos=top HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPos=top 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

ratingBarPos * (string)

Text including preferred rating bar position

Headers

Response Type

Response Headers

Response Body

Rating Bar Opacity Tier 3+

Rating bar opacity is set with a float value (ex: 0.5, 0.2).

While 0.0 or 0 are not supported, using 0.01 will make the rating bar completely transparent.

While 1.0 or 1 are not supported, using 0.99 will make the rating bar remove transparency.

Both posters and backdrops support ?ratingBarOpacity=

GET Example

/{apiKey}/{idType}/poster-certs/{mediaId}.jpg?ratingBarOpacity={ratingBarOpacity}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
ratingBarOpacity required	string	Text including preferred rating bar opacity

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarOpacity=0.5'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarOpacity=0.5", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarOpacity=0.5",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarOpacity=0.5"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarOpacity=0.5",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarOpacity=0.5")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarOpacity=0.5"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarOpacity=0.5"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarOpacity=0.5");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarOpacity=0.5 HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarOpacity=0.5 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

ratingBarOpacity * (string)

Text including preferred rating bar opacity

Headers

Response Type

Response Headers

Response Body

Rating Bar Background Color Tier 3+

The rating bar background color is set with a text value for the HTML color name (ex: red, blue) or the hex value of the color (ex: #FFE4C4).

Both posters and backdrops support ?ratingBarColor=

GET Example

/{apiKey}/{idType}/poster-certs/{mediaId}.jpg?ratingBarColor={ratingBarColor}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
ratingBarColor required	string	Text including preferred rating bar color

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarColor=blue'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarColor=blue", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarColor=blue",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarColor=blue"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarColor=blue",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarColor=blue")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarColor=blue"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarColor=blue"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarColor=blue");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarColor=blue HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarColor=blue 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

ratingBarColor * (string)

Text including preferred rating bar color

Headers

Response Type

Response Headers

Response Body

Rating Bar Type Tier 3+

The rating bar type can be either "bar" (default) or "blocks". The "blocks" type supports exclusive settings such as "ratingBarRoundness" and "ratingBarPadding".

GET Example

/{apiKey}/{idType}/poster-certs/{mediaId}.jpg?ratingBarType={ratingBarType}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
ratingBarType required	string	Rating bar type (either `bar` or `blocks`)

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarType=blocks'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarType=blocks", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarType=blocks",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarType=blocks"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarType=blocks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarType=blocks")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarType=blocks"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarType=blocks"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarType=blocks");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarType=blocks HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarType=blocks 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

ratingBarType * (string)

Rating bar type (either bar or blocks)

Headers

Response Type

Response Headers

Response Body

Rating Bar Roundness Tier 3+

The rating bar roundness applies only for "blocks" ratingBarType or supported themes (that include "blocks" or "stripes" in the name), it can be set to "default" (minimal rounded corners), "full" (completely rounded corners) or any number (pixels) including "0" (sharp corners).

GET Example

/{apiKey}/{idType}/poster-certs/{mediaId}.jpg?ratingBarRoundness={ratingBarRoundness}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
ratingBarRoundness required	string	Rating block corner roundness for supported themes

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarRoundness=full'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarRoundness=full", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarRoundness=full",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarRoundness=full"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarRoundness=full",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarRoundness=full")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarRoundness=full"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarRoundness=full"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarRoundness=full");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarRoundness=full HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarRoundness=full 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

ratingBarRoundness * (string)

Rating block corner roundness for supported themes

Headers

Response Type

Response Headers

Response Body

Rating Bar Padding Tier 3+

The rating block padding applies only for "blocks" ratingBarType or supported themes (that include "blocks" or "stripes" in the name), it can be set to any number (pixels) including "0".

GET Example

/{apiKey}/{idType}/poster-certs/{mediaId}.jpg?ratingBarPadding={ratingBarPadding}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
ratingBarPadding required	string	Rating block padding for supported themes

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPadding=15'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPadding=15", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPadding=15",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPadding=15"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPadding=15",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPadding=15")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPadding=15"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPadding=15"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPadding=15");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPadding=15 HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarPadding=15 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

ratingBarPadding * (string)

Rating block padding for supported themes

Headers

Response Type

Response Headers

Response Body

Rating Bar Margin Tier 3+

The rating block margin applies only for "blocks" ratingBarType or supported themes (that include "blocks" or "stripes" in the name), it can be set to any number (pixels) including "0".

GET Example

/{apiKey}/{idType}/poster-certs/{mediaId}.jpg?ratingBarMargin={ratingBarMargin}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
ratingBarMargin required	string	Rating block padding for supported themes

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarMargin=15'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarMargin=15", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarMargin=15",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarMargin=15"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarMargin=15",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarMargin=15")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarMargin=15"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarMargin=15"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarMargin=15");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarMargin=15 HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarMargin=15 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

ratingBarMargin * (string)

Rating block padding for supported themes

Headers

Response Type

Response Headers

Response Body

Rating Bar Stroke Width Tier 3+

The rating bar stroke width applies only for "blocks" ratingBarType or supported themes (that include "blocks" or "stripes" in the name), it can be set to "default" (minimal stroke width) or any number (pixels) including "0" (no width).

GET Example

/{apiKey}/{idType}/poster-certs/{mediaId}.jpg?ratingBarStrokeWidth={ratingBarStrokeWidth}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
ratingBarStrokeWidth required	string	Rating block corner roundness for supported themes

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeWidth=full'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeWidth=full", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeWidth=full",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeWidth=full"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeWidth=full",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeWidth=full")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeWidth=full"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeWidth=full"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeWidth=full");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeWidth=full HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeWidth=full 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

ratingBarStrokeWidth * (string)

Rating block corner roundness for supported themes

Headers

Response Type

Response Headers

Response Body

Rating Bar Stroke Color Tier 3+

The rating bar stroke side applies only for "blocks" ratingBarType or supported themes (that include "blocks" or "stripes" in the name), it can be set to "default" (all sides) or one of the following: "right", "left", "top", "bottom"

GET Example

/{apiKey}/{idType}/poster-certs/{mediaId}.jpg?ratingBarStrokeColor={ratingBarStrokeColor}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
ratingBarStrokeColor required	string	Stroke color

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeColor=red'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeColor=red", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeColor=red",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeColor=red"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeColor=red",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeColor=red")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeColor=red"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeColor=red"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeColor=red");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeColor=red HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarStrokeColor=red 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

ratingBarStrokeColor * (string)

Stroke color

Headers

Response Type

Response Headers

Response Body

Rating Bar Stroke Side Tier 3+

The rating bar stroke side applies only for "blocks" ratingBarType or supported themes (that include "blocks" or "stripes" in the name), it can be set to "default" (all sides) or one of the following: "right", "left", "top", "bottom"

GET Example

/{apiKey}/{idType}/poster-certs/{mediaId}.jpg?strokeSide={strokeSide}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
strokeSide required	string	Stroke side

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?strokeSide=right'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?strokeSide=right", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-certs/tt2395427.jpg?strokeSide=right",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?strokeSide=right"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?strokeSide=right",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?strokeSide=right")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?strokeSide=right"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?strokeSide=right"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?strokeSide=right");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-certs/tt2395427.jpg?strokeSide=right HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?strokeSide=right 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

strokeSide * (string)

Stroke side

Headers

Response Type

Response Headers

Response Body

Rating Bar Skew Direction Tier 3+

The rating block skew direction, applies only for "blocks" ratingBarType or supported themes (that include "blocks"), it can be set to: "left" or "right".

GET Example

/{apiKey}/{idType}/poster-certs/{mediaId}.jpg?ratingBarSkewDirection={ratingBarSkewDirection}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
ratingBarSkewDirection required	string	Color of the rating block border

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarSkewDirection=left'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarSkewDirection=left", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarSkewDirection=left",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarSkewDirection=left"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarSkewDirection=left",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarSkewDirection=left")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarSkewDirection=left"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarSkewDirection=left"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarSkewDirection=left");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarSkewDirection=left HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?ratingBarSkewDirection=left 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

ratingBarSkewDirection * (string)

Color of the rating block border

Headers

Response Type

Response Headers

Response Body

Rating Bar Font Color Tier 3+

The rating bar font color is set with a text value for the HTML color name (ex: red, blue) or the hex value of the color (ex: #FFE4C4).

Both posters and backdrops support ?fontColor=

GET Example

/{apiKey}/{idType}/poster-certs/{mediaId}.jpg?fontColor={fontColor}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
fontColor required	string	Text including preferred rating bar font color

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontColor=blue'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontColor=blue", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontColor=blue",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontColor=blue"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontColor=blue",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontColor=blue")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontColor=blue"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontColor=blue"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontColor=blue");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-certs/tt2395427.jpg?fontColor=blue HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?fontColor=blue 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

fontColor * (string)

Text including preferred rating bar font color

Headers

Response Type

Response Headers

Response Body

Logo Styles Tier 3+

Setting this value to "1" will make the rating logos round, setting this value to "2" will disable the logos.

GET Example

/{apiKey}/{idType}/poster-certs/{mediaId}.jpg?logoStyle={logoStyle}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
logoStyle required	string	If rating logo should be a round image or disabled

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?logoStyle=1'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?logoStyle=1", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/poster-certs/tt2395427.jpg?logoStyle=1",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?logoStyle=1"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?logoStyle=1",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?logoStyle=1")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?logoStyle=1"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?logoStyle=1"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?logoStyle=1");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/poster-certs/tt2395427.jpg?logoStyle=1 HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/poster-certs/tt2395427.jpg?logoStyle=1 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

logoStyle * (string)

If rating logo should be a round image or disabled

Headers

Response Type

Response Headers

Response Body

Backdrop Certificates Position Tier 3+

The certificates (such as "certified fresh" or "must watch") from the backdrops can be moved with the certsPos query parameter.

Only backdrops support ?certsPos=.

Available positions for backdrop certificates:

left (default)
right

GET Example

/{apiKey}/{idType}/backdrop-default/{mediaId}.jpg?certsPos={certsPos}

Parameters

Name	Type	Description
apiKey required	string	The user's API Key
idType required	string	The requesting id type, can be: `imdb`, `tmdb`, `tvdb`
mediaId required	string	The ID for the movie / series, depending on the chosen `idType`, when using the `tmdb` or `tvdb` id types you should also include the media type in the ID (TMDB/TVDB ID examples: `movie-155` or `series-155`)
certsPos required	string	Text including preferred backdrop certificate position

Response

200 image/jpeg

curl --request GET \
  --url 'https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg?certsPos=right'

fetch("https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg?certsPos=right", {
  method: "GET"
})
  .then(response => response.text())
  .then(data => console.log(data))
  .catch(err => console.error(err));

const https = require('https');

const options = {
  hostname: "api.ratingposterdb.com",
  port: 443,
  path: "/{apiKey}/imdb/backdrop-default/tt2395427.jpg?certsPos=right",
  method: "GET",
  headers: {}
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => { console.log(data); });
});

req.on('error', (err) => { console.error(err); });
req.end();

import requests

url = "https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg?certsPos=right"

response = requests.get(url)
print(response.text)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg?certsPos=right",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
curl_close($curl);

echo $response;

require 'uri'
require 'net/http'

url = URI("https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg?certsPos=right")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = url.scheme == 'https'

request = Net::HTTP::Get.new(url)

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg?certsPos=right"
	req, _ := http.NewRequest("GET", url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil { fmt.Println(err); return }
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

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

public class ApiCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest.Builder builder = HttpRequest.newBuilder()
      .uri(URI.create("https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg?certsPos=right"))
      .method("GET", HttpRequest.BodyPublishers.noBody());
    HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;

my $ua = LWP::UserAgent->new;
my $req = HTTP::Request->new("GET" => "https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg?certsPos=right");

my $res = $ua->request($req);
print $res->decoded_content;

GET /{apiKey}/imdb/backdrop-default/tt2395427.jpg?certsPos=right HTTP/1.1
Host: api.ratingposterdb.com

https://api.ratingposterdb.com/{apiKey}/imdb/backdrop-default/tt2395427.jpg?certsPos=right 📋

Parameters

apiKey * (string)

The user's API Key

idType * (string)

The requesting id type, can be: imdb, tmdb, tvdb

mediaId * (string)

The ID for the movie / series, depending on the chosen idType, when using the tmdb or tvdb id types you should also include the media type in the ID (TMDB/TVDB ID examples: movie-155 or series-155)

certsPos * (string)

Text including preferred backdrop certificate position

Headers

Response Type

Response Headers

Response Body