# Hodnocení filmů a seriálů

> GET /3/movie/{movie_id}/ratings a GET /3/tv/{tv_id}/ratings vracejí skóre z IMDb, Kinopoisk, Metacritic, Rotten Tomatoes a TMDB. Každý zdroj je objekt s value a votes, nebo null, když je neznámý. IMDb, Kinopoisk a TMDB jsou z 10, zbylé dva ze 100. Přidejte append_to_response=ratings a sloučíte je do detailů.

## Endpoint

`GET /3/movie/{movie_id}/ratings`

```bash
curl "https://api.amodb.dev/3/movie/550/ratings" \
  -H "Authorization: Bearer $AMODB_KEY"
```

Odpověď:

```json
{
  "id": 550,
  "imdb": {
    "value": 8.8,
    "votes": 2669989
  },
  "kinopoisk": {
    "value": 8.7,
    "votes": null
  },
  "metacritic": {
    "value": 67,
    "votes": null
  },
  "rotten_tomatoes": {
    "value": 81,
    "votes": null
  },
  "tmdb": {
    "value": 8.437,
    "votes": 33042
  }
}
```

## Získání hodnocení filmu

`GET /3/movie/{movie_id}/ratings` vrací skóre, která zdroje hodnocení zveřejňují pro jeden film. Odpověď má `id` filmu a pět klíčů zdrojů: `imdb`, `kinopoisk`, `metacritic`, `rotten_tomatoes` a `tmdb`. Každý klíč zdroje obsahuje objekt s `value` a `votes`, nebo `null`, když tento zdroj titul nezná.

Ukázka načte Fight Club (ID 550) a vypíše každý zdroj, neznámé označí.

```bash
curl -sf "https://api.amodb.dev/3/movie/550/ratings" \
  -H "Authorization: Bearer $AMODB_KEY"
```

```js
const res = await fetch('https://api.amodb.dev/3/movie/550/ratings', {
  headers: { Authorization: `Bearer ${process.env.AMODB_KEY}` },
});
if (!res.ok) throw new Error(`amodb returned ${res.status}`);
const ratings = await res.json();
for (const source of ['imdb', 'kinopoisk', 'metacritic', 'rotten_tomatoes', 'tmdb']) {
  const score = ratings[source];
  console.log(source, score ? `${score.value} (votes: ${score.votes ?? 'unknown'})` : 'not known');
}
```

```python
import os
import requests

r = requests.get(
    "https://api.amodb.dev/3/movie/550/ratings",
    headers={"Authorization": f"Bearer {os.environ['AMODB_KEY']}"},
    timeout=10,
)
r.raise_for_status()
ratings = r.json()
for source in ("imdb", "kinopoisk", "metacritic", "rotten_tomatoes", "tmdb"):
    score = ratings[source]
    if score is None:
        print(source, "not known")
    else:
        print(source, score["value"], "votes:", score["votes"] or "unknown")
```

```php
<?php
$ch = curl_init('https://api.amodb.dev/3/movie/550/ratings');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . getenv('AMODB_KEY')],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
if ($status !== 200) {
    throw new RuntimeException("amodb returned $status");
}
$ratings = json_decode($body, true);
foreach (['imdb', 'kinopoisk', 'metacritic', 'rotten_tomatoes', 'tmdb'] as $source) {
    $score = $ratings[$source];
    echo $source, ' ', $score === null ? 'not known' : $score['value'] . ' votes: ' . ($score['votes'] ?? 'unknown'), PHP_EOL;
}
```

```go
package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"time"
)

type Score struct {
	Value float64 `json:"value"`
	Votes *int    `json:"votes"`
}

type Ratings struct {
	IMDb           *Score `json:"imdb"`
	Kinopoisk      *Score `json:"kinopoisk"`
	Metacritic     *Score `json:"metacritic"`
	RottenTomatoes *Score `json:"rotten_tomatoes"`
	TMDB           *Score `json:"tmdb"`
}

func show(name string, s *Score) {
	if s == nil {
		fmt.Println(name, "not known")
		return
	}
	if s.Votes == nil {
		fmt.Println(name, s.Value, "votes: unknown")
		return
	}
	fmt.Println(name, s.Value, "votes:", *s.Votes)
}

func main() {
	req, _ := http.NewRequest("GET", "https://api.amodb.dev/3/movie/550/ratings", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("AMODB_KEY"))
	client := &http.Client{Timeout: 10 * time.Second}
	res, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	if res.StatusCode != http.StatusOK {
		panic(res.Status)
	}
	var r Ratings
	if err := json.NewDecoder(res.Body).Decode(&r); err != nil {
		panic(err)
	}
	show("imdb", r.IMDb)
	show("kinopoisk", r.Kinopoisk)
	show("metacritic", r.Metacritic)
	show("rotten_tomatoes", r.RottenTomatoes)
	show("tmdb", r.TMDB)
}
```

### Parametry

| Parametr   | Kde   | Povinný       | Popis                                                          |
| ---------- | ----- | ------------- | -------------------------------------------------------------- |
| `movie_id` | path  | ano           | Číselné ID filmu, například `550`.                             |
| `api_key`  | query | jeden ze dvou | Váš klíč. Použijte jej, nebo hlavičku `Authorization: Bearer`. |

### Pole odpovědi

| Pole              | Typ               | Poznámky                                                                           |
| ----------------- | ----------------- | ---------------------------------------------------------------------------------- |
| `id`              | integer           | ID filmu. Při použití `append_to_response` chybí.                                  |
| `imdb`            | object nebo null  | Skóre IMDb, z 10 na jedno desetinné místo.                                         |
| `kinopoisk`       | object nebo null  | Skóre Kinopoisk, z 10 na jedno desetinné místo.                                    |
| `metacritic`      | object nebo null  | Skóre Metacritic, ze 100 jako celé číslo.                                          |
| `rotten_tomatoes` | object nebo null  | Skóre Rotten Tomatoes, ze 100 jako celé číslo.                                     |
| `tmdb`            | object nebo null  | Skóre uživatelů TMDB, z 10 až na tři desetinná místa.                              |
| `value`           | number            | Uvnitř každého objektu zdroje. Skóre na vlastní stupnici daného zdroje.            |
| `votes`           | integer nebo null | Uvnitř každého objektu zdroje. Počet hlasů za skórem, nebo `null`, když není znám. |

Pět klíčů zdrojů čtěte podle názvu a ostatní klíče přeskočte. Klíče zdrojů vždy přicházejí ve stejném pořadí: `imdb`, `kinopoisk`, `metacritic`, `rotten_tomatoes`, `tmdb`.

### Příklad odpovědi

```json
{
  "id": 550,
  "imdb": { "value": 8.8, "votes": 2669989 },
  "kinopoisk": { "value": 8.7, "votes": null },
  "metacritic": { "value": 67, "votes": null },
  "rotten_tomatoes": { "value": 81, "votes": null },
  "tmdb": { "value": 8.437, "votes": 33039 }
}
```

Počet hlasů zde mají jen IMDb a TMDB. Kinopoisk, Metacritic a Rotten Tomatoes mají skóre a počet hlasů `null`.

## Získání hodnocení seriálu

`GET /3/tv/{tv_id}/ratings` má stejné klíče a stejná pravidla pro null. Předejte ID seriálu, například `1396` pro Breaking Bad.

| Metoda a cesta                    | Vrací             | Parametry  |
| --------------------------------- | ----------------- | ---------- |
| `GET /3/movie/{movie_id}/ratings` | `id` a pět zdrojů | `movie_id` |
| `GET /3/tv/{tv_id}/ratings`       | `id` a pět zdrojů | `tv_id`    |

```bash
curl -sf "https://api.amodb.dev/3/tv/1396/ratings" -H "Authorization: Bearer $AMODB_KEY"
```

Breaking Bad nemá skóre Metacritic, takže tento zdroj je `null`:

```json
{
  "id": 1396,
  "imdb": { "value": 9.5, "votes": 2671962 },
  "kinopoisk": { "value": 8.9, "votes": null },
  "metacritic": null,
  "rotten_tomatoes": { "value": 96, "votes": null },
  "tmdb": { "value": 9, "votes": 18863 }
}
```

## Přidání hodnocení k volání detailů

`append_to_response=ratings` funguje u detailů filmů i seriálů. Objekt přijde pod klíčem `ratings` vedle obvyklých polí, bez vlastního `id`. Stránka se seznamem potřebuje jeden požadavek na titul místo dvou.

| Požadavek                                       | Kde se skóre objeví                     |
| ----------------------------------------------- | --------------------------------------- |
| `/3/movie/550?append_to_response=ratings`       | `ratings` v záznamu filmu               |
| `/3/tv/1396?append_to_response=credits,ratings` | `ratings` a `credits` v záznamu seriálu |

Další hodnoty, které lze přidat, viz [detail filmu](https://amodb.dev/cs/movies/) a [seriály](https://amodb.dev/cs/tv-series/).

## Zdroje a hodnoty null

Zdroj null není nulové skóre. Znamená, že skóre pro titul chybí.

| Klíč              | Zdroj           | Stupnice | Popisek k zobrazení |
| ----------------- | --------------- | -------- | ------------------- |
| `imdb`            | IMDb            | 0 až 10  | IMDb                |
| `kinopoisk`       | Kinopoisk       | 0 až 10  | Kinopoisk           |
| `metacritic`      | Metacritic      | 0 až 100 | Metacritic          |
| `rotten_tomatoes` | Rotten Tomatoes | 0 až 100 | Rotten Tomatoes     |
| `tmdb`            | TMDB            | 0 až 10  | TMDB                |

Pokrytí se liší podle titulu, programujte proto proti null, ne proti pevnému seznamu zdrojů. Kterýkoli z pěti klíčů může být u kteréhokoli titulu null.

## Čím se hodnocení liší od vote_average

Pole `vote_average` a `vote_count` v záznamu filmu nebo seriálu jsou skóre uživatelů TMDB. Klíč `tmdb` nese stejné skóre ve stejném tvaru jako ostatní čtyři, takže jedno volání dá všech pět zdrojů v jednom formátu.

Každý zdroj má vlastní publikum a stupnici. Neprůměrujte je a neporovnávejte hodnotu jednoho zdroje s počtem hlasů jiného.

## Zobrazení hodnocení v aplikaci

Vykreslete jen zdroje, které jsou přítomné. Pro kartu stačí krátký seznam odznaků. Přidejte stupnici, aby čtenář rozeznal 8.8 z 10 od 67 ze 100.

```js
const labels = {
  imdb: ['IMDb', 10],
  kinopoisk: ['Kinopoisk', 10],
  metacritic: ['Metacritic', 100],
  rotten_tomatoes: ['Rotten Tomatoes', 100],
  tmdb: ['TMDB', 10],
};

function badges(ratings) {
  return Object.entries(labels)
    .filter(([key]) => ratings[key])
    .map(([key, [label, max]]) => `${label} ${ratings[key].value}/${max}`);
}
```

U každé hodnoty zobrazte popisek. Když je všech pět null, blok skryjte místo zobrazení prázdných odznaků.

## Chyby

Selhání zachovávají tělo chyby TMDB, kde `success` je false a `status_code` pojmenuje problém. Titul bez skóre mezi ně nepatří.

| HTTP | status_code | Kdy                                                                                   |
| ---- | ----------- | ------------------------------------------------------------------------------------- |
| 401  | 7           | Klíč chybí nebo je nesprávný.                                                         |
| 402  | 36          | Platnost tarifu skončila.                                                             |
| 404  | 34          | Film ani seriál s tímto ID neexistuje.                                                |
| 429  | 25          | Překročen počet požadavků za minutu. Počkejte tolik sekund, kolik říká `Retry-After`. |

Neznámé skóre je `null`, ne chyba. Podrobnosti jsou na stránkách [chyby](https://amodb.dev/cs/errors/) a [limity požadavků](https://amodb.dev/cs/rate-limits/).

## Praktické poznámky

- Hodnocení se na edge cachují 6 hodin, stejně jako detaily. Častější obnova vrací stejné tělo.
- Požadavek s `append_to_response=ratings` se počítá jako jeden požadavek z vašich 20, 40 nebo 120 požadavků za minutu.
- Ukládejte skóre s datem, kdy jste je stáhli. Hlasů přibývá a čísla se hýbou.
- Chcete-li ID z IMDb nebo Kinopoisku nejdřív převést na titul, použijte [hledání podle externího ID](https://amodb.dev/cs/find-by-external-id/). Pro pocity místo skóre viz [nálady](https://amodb.dev/cs/moods/).

## Otázky a odpovědi

### Proč je zdroj null?

Null znamená, že skóre pro daný titul chybí nebo je nulové. Nový titul nebo regionální film má často méně zdrojů než slavný, proto vždy ošetřete null, než číslo naformátujete. Pole votes může být také null.

### Čím se to liší od vote_average?

Pole vote_average v záznamu detailu je jen skóre uživatelů TMDB. Endpoint ratings je vrací znovu pod klíčem tmdb, na tři desetinná místa, a přidává další čtyři zdroje, každý jako value a votes.

### Mohu pět skóre zprůměrovat?

Nedělejte to. IMDb, Kinopoisk a TMDB jsou z 10, zatímco Metacritic a Rotten Tomatoes jsou ze 100. Každý zdroj má také vlastní publikum a některé jsou null. Zobrazte dostupné zdroje vedle sebe s popisky.

### Stojí volání hodnocení další požadavky?

Je to jeden požadavek jako každý jiný. S append_to_response=ratings přijdou skóre uvnitř volání detailů, takže spotřebujete jeden požadavek za minutu místo dvou.

## Související stránky

- [API detailu filmu](https://amodb.dev/cs/movies/): API detailu filmu se stejnými cestami a JSON jako TMDB v3. Načtěte film podle ID, přidejte obsazení, hodnocení a nálady přes append_to_response, 14 jazyků.
- [API detailu seriálu](https://amodb.dev/cs/tv-series/): API detailu seriálu se stejnými cestami a JSON jako TMDB v3. Seriál podle ID se sezónami, sítěmi, věkovým hodnocením a poskytovateli streamování.
- [Hledání podle externího ID](https://amodb.dev/cs/find-by-external-id/): Najděte film, seriál nebo osobu podle ID z IMDb, TVDB, Wikidata nebo Kinopoisk přes endpoint find TMDB a čtěte externí ID a fakta z Wikidata o titulu.
- [Měřiče nálady](https://amodb.dev/cs/moods/): API nálad filmů s měřiči na stupnici 0 až 10. Načtěte nálady filmu nebo seriálu, sloučte je přes append_to_response=moods a sestavte odznaky či filtry.
- [Limity požadavků](https://amodb.dev/cs/rate-limits/): amodb omezuje klíč počtem požadavků za minutu v klouzavém okně 60 sekund: 20, 40 nebo 120 podle tarifu. Čtěte hlavičky limitu a řešte 429 pomocí Retry-After.
- [Rychlý start](https://amodb.dev/cs/quickstart/): První volání amodb: získejte klíč, vyžádejte detail filmu v curl, JavaScriptu, Pythonu, PHP nebo Go a načtěte plakát z img.amodb.dev. Za méně než 2 minuty.

Aktualizováno: 2026-10-18. Source: https://amodb.dev/cs/ratings/
