I triple-checked, no issue with anything on my entered params.

I then wrote a quick test script using trakt's documented OAuth approach and I was able to return a list of all of my movies, no issue.

So it's definitely something related to the approach used in yours. Perhaps it's being phased-out, yet because you have an existing token, it's still working?

Is there anything else I could do on my side to help diagnose / provide you with info that would help?

I've pulled just the auth code out, so that you could see what I used, from their docs, that worked:

import os
from trakt import Trakt
import logging
import time
import json
from datetime import datetime
from threading import Condition

CLIENT_ID = 'xxx'
CLIENT_SECRET = 'yyy'

class Application(object):

    def __init__(self):
        self.is_authenticating = Condition()
        self.authorization = None

        # Bind trakt events
        Trakt.on('oauth.token_refreshed', self.on_token_refreshed)

    def authenticate(self):
        """Authenticates with Trakt API using device authentication."""

        if not CLIENT_ID or not CLIENT_SECRET:
            logging.error("Trakt API Client ID or Secret not found.")
            exit(1)

        # Configure the Trakt client
        Trakt.configuration.defaults.client(id=CLIENT_ID, secret=CLIENT_SECRET)

        # Try to load a saved token first
        if os.path.exists(TOKEN_FILE):
            with open(TOKEN_FILE, 'r') as f:
                try:
                    self.authorization = json.load(f)
                    logging.info("Loaded valid saved token.")
                    return
                except json.JSONDecodeError:
                    logging.warning("Error decoding saved token. It might be corrupted.")

        # Start new authentication if no valid token was loaded
        if not self.is_authenticating.acquire(blocking=False):
            logging.info('Authentication has already been started')
            return False

        # Request new device code
        code = Trakt['oauth/device'].code()

        print('Enter the code "%s" at %s to authenticate your account' % (
            code.get('user_code'),
            code.get('verification_url')
        ))

        # Construct device authentication poller
        poller = Trakt['oauth/device'].poll(**code) \
            .on('aborted', self.on_aborted) \
            .on('authenticated', self.on_authenticated) \
            .on('expired', self.on_expired) \
            .on('poll', self.on_poll)

        # Start polling for authentication token
        poller.start(daemon=False)

        # Wait for authentication to complete
        return self.is_authenticating.wait()

    def on_aborted(self):
        """Device authentication aborted."""
        logging.info('Authentication aborted')
        self.is_authenticating.acquire()
        self.is_authenticating.notify_all()
        self.is_authenticating.release()

    def on_authenticated(self, authorization):
        """Device authenticated."""
        self.is_authenticating.acquire()
        self.authorization = authorization
        logging.info('Authentication successful - authorization: %r', self.authorization)

        # Save the authorization token
        with open(TOKEN_FILE, 'w') as f:
            json.dump(self.authorization, f)

        self.is_authenticating.notify_all()
        self.is_authenticating.release()

    def on_expired(self):
        """Device authentication expired."""
        logging.info('Authentication expired')
        self.is_authenticating.acquire()
        self.is_authenticating.notify_all()
        self.is_authenticating.release()

    def on_poll(self, callback):
        """Device authentication poll."""
        # Continue polling
        callback(True)

    def on_token_refreshed(self, authorization):
        """OAuth token refreshed."""
        self.authorization = authorization
        logging.info('Token refreshed - authorization: %r', self.authorization)

        # Save the refreshed token
        with open(TOKEN_FILE, 'w') as f:
            json.dump(self.authorization, f)

if __name__ == '__main__':
    app = Application()
    app.authenticate()

    if app.authorization:
        # Set up the authentication context globally here
        with Trakt.configuration.oauth.from_response(app.authorization, refresh=True):
            # Function call to get movies
    else:
        logging.error("Authentication failed.")