Scrobbling playback

# Generic Python scrobbler. Drop into any player that has play/pause/stop hooks.
# Tested shape: works as-is from a Kodi service add-on, mpv Lua bridge, or any
# Python-driven player.
import requests

API = "https://api.simkl.com"
PARAMS = {
    "client_id":   "YOUR_CLIENT_ID",
    "app-name":    "my-app-name",
    "app-version": "1.0",
}
HEADERS = {
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "User-Agent":    "my-app-name/1.0",
    "Content-Type":  "application/json",
}

class Scrobbler:
    def __init__(self, item):
        # item example: {"movie": {"title": "Inception", "year": 2010,
        #                          "ids": {"imdb": "tt1375666"}}}
        self.item = item

    def _post(self, action, progress=None):
        body = dict(self.item)
        if progress is not None:
            body["progress"] = progress
        r = requests.post(f"{API}/scrobble/{action}",
                          params=PARAMS, headers=HEADERS, json=body, timeout=10)
        r.raise_for_status()
        return r.json()

    def start(self, progress=0):    return self._post("start",   progress)
    def pause(self, progress):      return self._post("pause",   progress)
    def stop(self,  progress):      return self._post("stop",    progress)
    def checkin(self):              return self._post("checkin")

# Wire-up: call from your player's onPlaybackStarted / onPaused / onStopped hooks.
# scrob = Scrobbler({"movie": {"title": "Inception", "year": 2010,
#                              "ids": {"imdb": "tt1375666"}}})
# scrob.start(0)             # on play
# scrob.pause(45.2)          # on pause, with current progress %
# scrob.start(45.2)          # on resume
# scrob.stop(100)            # on natural end -> marks watched

// Drop-in scrobbler for an HTML5 <video> element or a browser extension.
const API = "https://api.simkl.com";
const QS  = new URLSearchParams({
  client_id:     "YOUR_CLIENT_ID",
  "app-name":    "my-app-name",
  "app-version": "1.0",
});
const HEADERS = {
  "Authorization": "Bearer USER_ACCESS_TOKEN",
  "User-Agent":    "my-app-name/1.0",
  "Content-Type":  "application/json",
};

class Scrobbler {
  constructor(item) { this.item = item; }
  async _post(action, progress) {
    const body = progress == null ? this.item : { ...this.item, progress };
    const res  = await fetch(`${API}/scrobble/${action}?${QS}`, {
      method: "POST", headers: HEADERS, body: JSON.stringify(body),
    });
    if (!res.ok) throw new Error(`scrobble ${action} ${res.status}`);
    return res.json();
  }
  start(p = 0) { return this._post("start",   p); }
  pause(p)     { return this._post("pause",   p); }
  stop(p)      { return this._post("stop",    p); }
  checkin()    { return this._post("checkin"); }
}

// Wire-up to a <video> element. Progress is computed from currentTime / duration.
const video = document.querySelector("video");
const scrob = new Scrobbler({
  movie: { title: "Inception", year: 2010, ids: { imdb: "tt1375666" } },
});
const pct = () => (video.duration ? (video.currentTime / video.duration) * 100 : 0);

video.addEventListener("play",   () => scrob.start(pct()));
video.addEventListener("pause",  () => scrob.pause(pct()));
video.addEventListener("ended",  () => scrob.stop(100));
window.addEventListener("beforeunload", () => scrob.stop(pct()));

import AVFoundation
import Foundation

let api  = URL(string: "https://api.simkl.com")!
let qs   = "client_id=YOUR_CLIENT_ID&app-name=my-app-name&app-version=1.0"
let auth = "Bearer USER_ACCESS_TOKEN"

final class Scrobbler {
    let item: [String: Any]   // e.g. ["movie": ["title": "Inception", "year": 2010,
                              //                "ids": ["imdb": "tt1375666"]]]
    init(item: [String: Any]) { self.item = item }

    func post(_ action: String, progress: Double? = nil) {
        var body = item
        if let p = progress { body["progress"] = p }
        var req = URLRequest(url: api.appendingPathComponent("scrobble/\(action)")
                                     .appending(query: qs))
        req.httpMethod = "POST"
        req.setValue(auth,                  forHTTPHeaderField: "Authorization")
        req.setValue("application/json",    forHTTPHeaderField: "Content-Type")
        req.setValue("my-app-name/1.0",     forHTTPHeaderField: "User-Agent")
        req.httpBody = try? JSONSerialization.data(withJSONObject: body)
        URLSession.shared.dataTask(with: req).resume()
    }
    func start(_ p: Double = 0) { post("start",   progress: p) }
    func pause(_ p: Double)     { post("pause",   progress: p) }
    func stop(_  p: Double)     { post("stop",    progress: p) }
    func checkin()              { post("checkin") }
}

// Wire-up: observe AVPlayer time + rate.
let player = AVPlayer(url: mediaURL)
let scrob  = Scrobbler(item: ["movie": ["title": "Inception", "year": 2010,
                                        "ids": ["imdb": "tt1375666"]]])
func progress() -> Double {
    guard let d = player.currentItem?.duration.seconds, d > 0 else { return 0 }
    return player.currentTime().seconds / d * 100
}
player.addObserver(forKeyPath: "rate") { rate in
    rate > 0 ? scrob.start(progress()) : scrob.pause(progress())
}
NotificationCenter.default.addObserver(forName: .AVPlayerItemDidPlayToEndTime,
                                       object: player.currentItem, queue: .main) { _ in
    scrob.stop(100)
}

import fetch from "node-fetch";

const API     = "https://api.simkl.com";
const QS      = "client_id=YOUR_CLIENT_ID&app-name=my-app-name&app-version=1.0";
const HEADERS = {
  "Authorization": "Bearer USER_ACCESS_TOKEN",
  "User-Agent":    "my-app-name/1.0",
  "Content-Type":  "application/json",
};

type Item = { movie?: object; show?: object; anime?: object; episode?: object };

export class Scrobbler {
  constructor(private readonly item: Item) {}

  private async post(action: string, progress?: number) {
    const body = progress == null ? this.item : { ...this.item, progress };
    const res  = await fetch(`${API}/scrobble/${action}?${QS}`, {
      method: "POST", headers: HEADERS, body: JSON.stringify(body),
    });
    if (!res.ok) throw new Error(`scrobble ${action} ${res.status}`);
    return res.json();
  }
  start  = (p = 0)   => this.post("start",   p);
  pause  = (p: number) => this.post("pause", p);
  stop   = (p: number) => this.post("stop",  p);
  checkin = ()       => this.post("checkin");
}

// Wire-up: in an addon SDK, dispatch on player events emitted by the host.
// const scrob = new Scrobbler({ movie: { title: "Inception", year: 2010,
//                                        ids: { imdb: "tt1375666" } } });
// host.on("play",   ({ progress }) => scrob.start(progress));
// host.on("pause",  ({ progress }) => scrob.pause(progress));
// host.on("ended",  ()             => scrob.stop(100));
// host.on("close",  ({ progress }) => scrob.stop(progress));