# Indicatori di mood

> GET /3/movie/{movie_id}/moods e GET /3/tv/{tv_id}/moods restituiscono una source e una lista results. Ogni risultato ha il nome di un mood come fear o humor, un avg su una scala da 0 a 10 e i valori che lo compongono. Aggiungi append_to_response=moods a una chiamata di dettagli per unire gli indicatori senza una seconda richiesta.

## Endpoint

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

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

Risposta:

```json
{
  "id": 155,
  "source": "measured",
  "results": [
    {
      "name": "action",
      "avg": 3.9,
      "values": [
        3.6,
        3.4,
        4.2
      ]
    },
    {
      "name": "fear",
      "avg": 5.2,
      "values": [
        3.6,
        6,
        4.8
      ]
    },
    {
      "name": "humor",
      "avg": 0.9,
      "values": [
        2.4,
        1.8,
        0.4
      ]
    }
  ]
}
```

## Ottenere gli indicatori di mood di un film

`GET /3/movie/{movie_id}/moods` restituisce gli indicatori di mood di un film. Un indicatore di mood è un nome e una media su una scala da 0 a 10. La risposta contiene l'`id` del film, una `source` e un array `results`. Ogni risultato contiene `name`, `avg` e `values`.

L'esempio carica gli indicatori di The Dark Knight (id 155) e li stampa dal più forte al più debole.

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

```js
const res = await fetch('https://api.amodb.dev/3/movie/155/moods', {
  headers: { Authorization: `Bearer ${process.env.AMODB_KEY}` },
});
if (!res.ok) throw new Error(`amodb returned ${res.status}`);
const { source, results } = await res.json();
console.log('source:', source);
for (const m of [...results].sort((a, b) => b.avg - a.avg)) {
  console.log(m.name.padEnd(10), m.avg);
}
```

```python
import os
import requests

r = requests.get(
    "https://api.amodb.dev/3/movie/155/moods",
    headers={"Authorization": f"Bearer {os.environ['AMODB_KEY']}"},
    timeout=10,
)
r.raise_for_status()
data = r.json()
print("source:", data.get("source"))
for m in sorted(data["results"], key=lambda m: m["avg"], reverse=True):
    print(f"{m['name']:<10} {m['avg']}")
```

```php
<?php
$ch = curl_init('https://api.amodb.dev/3/movie/155/moods');
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");
}
$data = json_decode($body, true);
echo 'source: ', $data['source'] ?? 'none', PHP_EOL;
$results = $data['results'];
usort($results, fn ($a, $b) => $b['avg'] <=> $a['avg']);
foreach ($results as $m) {
    printf("%-10s %.1f\n", $m['name'], $m['avg']);
}
```

```go
package main

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

type Mood struct {
	Name   string    `json:"name"`
	Avg    float64   `json:"avg"`
	Values []float64 `json:"values"`
}

func main() {
	req, _ := http.NewRequest("GET", "https://api.amodb.dev/3/movie/155/moods", 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 body struct {
		Source  string `json:"source"`
		Results []Mood `json:"results"`
	}
	if err := json.NewDecoder(res.Body).Decode(&body); err != nil {
		panic(err)
	}
	fmt.Println("source:", body.Source)
	sort.Slice(body.Results, func(i, j int) bool { return body.Results[i].Avg > body.Results[j].Avg })
	for _, m := range body.Results {
		fmt.Printf("%-10s %.1f\n", m.Name, m.Avg)
	}
}
```

### Parametri

| Parametro  | In       | Obbligatorio | Descrizione                                                   |
| ---------- | -------- | ------------ | ------------------------------------------------------------- |
| `movie_id` | percorso | sì           | ID numerico del film, per esempio `155`.                      |
| `api_key`  | query    | uno dei due  | La tua chiave. Usa questa o l'header `Authorization: Bearer`. |

### Campi della risposta

| Campo              | Tipo            | Note                                                                                                               |
| ------------------ | --------------- | ------------------------------------------------------------------------------------------------------------------ |
| `id`               | intero          | ID del film.                                                                                                       |
| `source`           | stringa o null  | `measured` per dati degli spettatori, `estimated` quando ricavati dai generi, `null` quando il titolo non ha dati. |
| `results`          | array           | Indicatori di mood ordinati per `name`. Vuoto quando non si sa nulla.                                              |
| `results[].name`   | stringa         | Breve parola in minuscolo come `fear`.                                                                             |
| `results[].avg`    | numero          | Media su una scala da 0 a 10. Un decimale per i titoli misurati, un numero intero per quelli stimati.              |
| `results[].values` | array di numeri | Fino a 24 rilevazioni sulla stessa scala da 0 a 10. I titoli misurati visti ne hanno 6, quelli stimati ne hanno 5. |

I nomi visti oggi sono `action`, `fear`, `humor`, `pace`, `profanity`, `romance`, `sadness`, `sex` e `violence`. Non tutti i titoli hanno tutti e nove, quindi mostra i nomi presi dai dati e non da un elenco fisso.

### Risposta di esempio

```json
{
  "id": 155,
  "source": "measured",
  "results": [
    { "name": "action", "avg": 3.9, "values": [3.6, 3.4, 4.2, 4.2, 4.8, 3] },
    { "name": "fear", "avg": 5.2, "values": [3.6, 6, 4.8, 6.4, 6.4, 3.8] },
    { "name": "humor", "avg": 0.9, "values": [2.4, 1.8, 0.4, 0.4, 0, 0.5] }
  ]
}
```

L'elenco è tagliato a 3 dei 9 risultati.

### Titoli misurati e stimati

Fight Club (id 550) non ha ancora dati degli spettatori, quindi i suoi indicatori sono ricavati dai suoi generi. Ogni `avg` è un numero intero e `values` ha 5 voci.

```json
{
  "id": 550,
  "source": "estimated",
  "results": [
    { "name": "action", "avg": 4, "values": [3, 4, 5, 4, 3] },
    { "name": "fear", "avg": 7, "values": [6, 7, 8, 7, 6] }
  ]
}
```

Controlla `source` se vuoi trattare gli indicatori stimati in modo diverso da quelli misurati.

## Ottenere gli indicatori di mood di una serie

`GET /3/tv/{tv_id}/moods` ha la stessa struttura di risposta, con l'ID della serie in `id`. Per Breaking Bad usa `1396`.

| Metodo e percorso             | Restituisce                        | Parametri                                      |
| ----------------------------- | ---------------------------------- | ---------------------------------------------- |
| `GET /movie/{movie_id}/moods` | `id`, `source` e `results`         | `movie_id`                                     |
| `GET /tv/{tv_id}/moods`       | `id`, `source` e `results`         | `tv_id`                                        |
| `append_to_response=moods`    | `source` e `results` sotto `moods` | Aggiunto ai dettagli di un film o di una serie |

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

Quando aggiungi `moods` a una chiamata di dettagli, la chiave `moods` sta al livello principale della scheda accanto a `title` o `name`. Contiene `source` e `results` e non ha un `id` proprio. Costa una richiesta, mentre due chiamate separate ne costano due.

## Come leggere la scala

Il campo `avg` è un'intensità da 0 a 10. Un numero più alto significa che il mood è più forte nel titolo.

| Intervallo | Lettura                      |
| ---------- | ---------------------------- |
| da 0 a 2.9 | Il mood è debole o assente.  |
| da 3 a 5.9 | Il mood è presente.          |
| da 6 a 7.9 | Il mood è evidente.          |
| da 8 a 10  | Il mood definisce il titolo. |

Le fasce sono un suggerimento per la tua interfaccia, non un campo della risposta. L'array `values` contiene le rilevazioni dietro la media, sulla stessa scala.

## Costruire badge e filtri

I mood si adattano a tre modelli di interfaccia comuni. Scegli soglie adatte al tuo catalogo e regolale.

| Modello          | Regola                                                           | Note                                                             |
| ---------------- | ---------------------------------------------------------------- | ---------------------------------------------------------------- |
| Badge            | Mostra fino a 3 mood con `avg` pari o superiore a 6              | Ordina prima per `avg`.                                          |
| Barra indicatore | Imposta la larghezza della barra a `avg` per 10 come percentuale | La scala va da 0 a 10.                                           |
| Chip di filtro   | Tieni i titoli in cui il mood scelto è pari o superiore a 7      | Recupera gli indicatori titolo per titolo, poi filtra in locale. |

```js
function topMoods(results, min = 6, limit = 3) {
  return results
    .filter((m) => m.avg >= min)
    .sort((a, b) => b.avg - a.avg)
    .slice(0, limit)
    .map((m) => m.name);
}

function matchesMood(results, name, min = 7) {
  return results.some((m) => m.name === name && m.avg >= min);
}
```

Un array `results` vuoto va mostrato come assenza di badge, non come un errore.

## Errori

Il corpo dell'errore ha `success`, `status_code` e `status_message`, gli stessi campi di TMDB.

| HTTP | status_code | Quando                                                                |
| ---- | ----------- | --------------------------------------------------------------------- |
| 401  | 7           | La chiave manca o è sbagliata.                                        |
| 402  | 36          | Il periodo del piano è terminato.                                     |
| 429  | 25          | Oltre le tue richieste al minuto. Attendi i secondi di `Retry-After`. |

L'endpoint dei mood non risponde 404 per un ID sconosciuto. Risponde 200 con un array `results` vuoto, e `source` è `null` o manca. Aggiunto ai dettagli, un ID sconosciuto dà un 404 dalla chiamata dei dettagli. L'elenco completo è nella pagina [errori](https://amodb.dev/it/errors/), e i limiti sono in [limiti di richieste](https://amodb.dev/it/rate-limits/).

## Note pratiche

- Come gli altri dati dei dettagli, gli indicatori di mood restano in cache sull'edge per 6 ore. Richiederli più spesso restituisce lo stesso corpo.
- Una lista di 20 titoli richiede 20 richieste di mood. Se già chiami i dettagli per ogni titolo, aggiungi `moods` e risparmia la seconda chiamata.
- Controlla `source` prima di confrontare i titoli. Gli indicatori misurati e stimati usano la stessa scala ma non la stessa precisione.
- Salva `name` e `avg` insieme all'ID del titolo nel tuo database se filtri spesso. Un filtro locale vale più di una richiesta per titolo.
- Combina gli indicatori con le [valutazioni](https://amodb.dev/it/ratings/) per un punteggio e con le [colonne sonore](https://amodb.dev/it/soundtracks/) per la musica dello stesso titolo.

## Domande e risposte

### Cosa significa un valore di mood?

Il campo avg è un'intensità su una scala da 0 a 10, con un decimale per i titoli misurati. Un avg di 7 per fear significa che il titolo fa paura, e 0 significa che il mood è assente. Non è una percentuale né un voto di recensione.

### L'elenco dei nomi dei mood è fisso?

Non darlo per scontato. I nomi visti oggi sono action, fear, humor, pace, profanity, romance, sadness, sex e violence, e un titolo può averne meno di nove. Mostra le stringhe dei nomi che ricevi così ne comparirà anche uno nuovo.

### Cosa significano measured ed estimated in source?

Measured significa che gli indicatori vengono da dati degli spettatori e hanno decimali. Estimated significa che sono ricavati dai generi del titolo, quindi avg è un numero intero. Un titolo senza dati ha un array results vuoto e una source null.

### Come filtro una lista di titoli per mood?

Recupera gli indicatori di ogni titolo della tua lista, con l'endpoint moods o con append_to_response sui dettagli, e tieni i titoli in cui il mood scelto supera la tua soglia. Il filtro gira nel tuo codice.

### Anche le serie TV hanno i mood?

Sì. Usa GET /3/tv/{tv_id}/moods, per esempio con l'ID serie 1396. La risposta ha la stessa struttura dell'endpoint dei film.

## Pagine correlate

- [API dei dettagli del film](https://amodb.dev/it/movies/): API dettagli film con gli stessi percorsi e JSON di TMDB v3. Ottieni un film per ID, aggiungi crediti, valutazioni e mood con append_to_response, in 14 lingue.
- [API delle serie TV](https://amodb.dev/it/tv-series/): API serie TV con gli stessi percorsi e JSON di TMDB v3. Ottieni una serie per ID con stagioni, emittenti e prossimo episodio, più classificazioni e piattaforme.
- [Valutazioni di film e serie TV](https://amodb.dev/it/ratings/): API valutazioni film: punteggi IMDb, Kinopoisk, Metacritic, Rotten Tomatoes e TMDB di un titolo in una chiamata, con null per le fonti non note.
- [Colonne sonore](https://amodb.dev/it/soundtracks/): API colonne sonore che restituisce l'album di un film o serie TV con la lista dei brani. Chiama l'endpoint o aggiungi append_to_response=soundtracks.
- [API Discover](https://amodb.dev/it/discover/): API Discover con gli stessi filtri di TMDB v3. Elenca film e serie TV per genere, cast, società, parola chiave, anno, voto, durata e piattaforma.
- [Avvio rapido](https://amodb.dev/it/quickstart/): Fai la prima chiamata ad amodb: ottieni una chiave, richiedi i dettagli di un film in curl, JavaScript, Python, PHP o Go, carica la locandina. Meno di 2 minuti.

Aggiornato: 2026-10-18. Source: https://amodb.dev/it/moods/
