The purpose of NewType is purely for static type checking, but for dynamic purposes it produces the wrapped type. It does not make a new type at all, it returns a callable that the static type checker can see, that's all.

When you do:

x = MyStr("Hello World")

it doesn't produce a new instance of MyStr, it returns "Hello World" entirely unchanged, it's still the original str passed in, even down to identity:

>>> s = ' '.join(["a", "b", "c"])  # Make a new string in a way that foils interning, just to rule out any weirdness from caches
>>> ms = MyStr(s)  # "Convert" it to MyStr
>>> type(ms)       # It's just a str
str
>>> s is ms        # It's even the *exact* same object you passed in
True

The point is, what NewType(...) returns is effectively a callable that:

1. Acts as the identity function (it returns whatever you give it unchanged); in modern Python, NewType itself is a class that begins with __call__ = _idfunc, that's literally just saying when you make a call with an instance, return the argument unchanged.
2. (In modern Python) Has some useful features like overloading | to produce Unions like other typing-friendly things.

but you can't use it usefully for isinstance, not because it's not producing instances of anything.

As other answers have mentioned, if you need runtime, dynamic checking, subclassing is the way to go. The other answers are doing both more (unnecessarily implementing __new__) and less (allowing arbitrary attributes, bloating instances of the subclass for a benefit you won't use) than necessary, so here's what you want for something that:

1. Is considered a subclass of str for both static and runtime checking purposes
2. Does not bloat the memory usage per-instance any more than absolutely necessary

class MyStr(str):   # Inherit all behaviors of str
    __slots__ = ()  # Prevent subclass from having __dict__ and __weakref__ slots, saving 16 bytes
                    # per instance on 64 bit CPython builds, and avoiding weirdness like allowing
                    # instance attributes on a logical str

That's it, just two lines (technically, a one-liner like class MyStr(str): __slots__ = () is syntactically legal, but it's bad style, so I avoid it), and you've got what you need.

UserId you created with NewType only works for type annotations. Type annotations are only for static analysis (at least up till now), so IDEs like pycharm and tools like mypy use it to implement auto complete or error checking, etc.

If you want a "real" UserId type (a type at runtime), you can subclass int by yourself.

class UserId(int):
    pass

print(UserId(3))
# By the way, UserId('Hello world!') will raise ValueError

A this time, after some experimentations, I'm using this recipe:

class TypedMeta(type):
    """Metaclass used for custom types."""

    def __instancecheck__(cls, obj):
        return cls._test(obj)

    @staticmethod
    def _init(self, x):
        if not self._test(x):
            raise ValueError(f"bad value for '{self.__class__.__name__}' object")

    def __init__(cls, name, bases, clsdict):
        if not clsdict.get('_test'):
            raise TypeError(f"cannot instaciate '{name}' class without '_test' method")
        setattr(cls, '__init__', TypedMeta._init)


class posint(int, metaclass=TypedMeta):
    """Strictly positive 'int'."""

    @classmethod
    def _test(cls, val):
        return val > 0

So even if somebody wants to instantiate an object of this type, or to cast another into it, it will perform the _test method first.