The selected answer, although not wrong, doesn't reflect the actual use of Protocol, which is providing structural subtyping. Nominal subtyping was always available to Python 3.

from typing import Protocol, runtime_checkable

@runtime_checkable
class Closable(Protocol):
    def close(self):
        ...

class AnyClass:
    def close(self):
        ...

issubclass(AnyClass, Closable)
#> True

Also, runtime_checkable is only needed in the base class, even if the class being checked is a Protocol subclass.

class ExtendedProtocol(Closable, Protocol):
    ...

class AnotherProtocol(Protocol):
    def close(self):
        ...

class NotAProtocol(Closable):
    # just inherits the protocol's default implementation
    ...

issubclass(ExtendedProtocol, Closable)
#> True
issubclass(AnotherProtocol, Closable)
#> True
issubclass(NotAProtocol, Closable)
#> True

I'll go through the problems one by one.

Given the following protocols for file-like objects:

from typing import Any, Protocol, TypeVar, runtime_checkable

T_co = TypeVar('T_co', covariant=True)


@runtime_checkable
class SupportsRead(Protocol[T_co]):
    def read(self, __length: int = ...) -> T_co: ...


@runtime_checkable
class SupportsWrite(Protocol[T_co]):
    def write(self, data: str | bytes) -> Any: ...

SerializerToFile

Simply adjusting your protocol members' parameter names to reflect those of the corresponding functions in the json module fixes the issue:

@runtime_checkable
class SerializerToFile(Protocol):
    def dump(
        self,
        obj: Any,                        # was called `value`
        fp: SupportsWrite[str | bytes],  # was called `file`
        **kwargs: Any,                   # was missing `Any` (optional)
    ) -> None: ...

    def load(
        self,
        fp: SupportsRead[str | bytes],  # was called `file`
        **kwargs: Any,                  # was missing `Any` (optional)
    ) -> Any: ...


import json

var1: SerializerToFile = json  # passes

SerializerToString

Again, the names did not match, but also your protocol methods accept arbitrary positional arguments, which neither the loads nor the dumps function does:

@runtime_checkable
class SerializerToString(Protocol):
    def dumps(
        self,
        obj: Any,       # was called `value`
        # *argv: Any,   # this needs to be removed
        **kwargs: Any,  # was missing `Any` (optional)
    ) -> str: ...

    def loads(
        self,
        s: str | bytes,  # was called `value`
        # *argv: Any,    # this needs to be removed
        **kwargs: Any,   # was missing `Any` (optional)
    ) -> Any: ...


import json

var1: SerializerToString = json  # passes

Serializer (intersection)

With the fixed protocols from above, the intersection of both of them is also a valid annotation to use for the json module:

...

@runtime_checkable
class Serializer(SerializerToString, SerializerToFile, Protocol):
    pass


import json

var1: Serializer = json  # passes

Custom serializer

Now the custom serializer needs to be adjusted accordingly, so that it matches the protocol as well:

...

class MySerializer:
    def dumps(self, obj: Any, **_kwargs: Any) -> str:
        return f"dumps {obj}"

    def loads(self, s: str | bytes, **_kwargs: Any) -> Any:
        return f"loads {s!r}"


var1: SerializerToString = MySerializer()  # passes

The first loads argument must accept bytes as well, since the protocol defines it as str | bytes. Subtypes are contravariant in their method parameters. So you could only widen the parameter types accepted by the serializer, never narrow it. Something silly like str | bytes | tuple[Any] for the first argument on your loads method would still work, but just str does not.

Attempt at explanation

As opposed to the Callable type, where you may only define the types that parameters in certain positions of the callable take, the protocol methods are more specific, since Python does allow all "normal" arguments to a function call to be passed as keyword-arguments (i.e. by name).

The exceptions are variable-number positional arguments, defined via *args and arguments specifically defined as positional-only by having their parameters precede a / in the signature.

So if you say that something is a structural subtype of e.g. SerializerToFile, if it implements a method dumps, where the first parameter is "positional-or-keyword" and named value, you could then use an object of that type somewhere and call that method as dumps(value=123). But the json.dumps method can not be called that way because its first parameter is named obj, so a call of json.dumps(obj={}) works, whereas the call json.dumps(value={}) would fail. Therefore json does not conform to the protocol.

Similarly, if your protocol allows "var. args" in a method, i.e. dumps(obj: Any, *args: Any, **kwargs: Any), that means you might want to call that method on an instance of that type as dumps({}, 1, 2, 3, 4), but that is not allowed for json.dumps because aside from the very first parameter it explicitly defines the rest as keyword-only (all following the *).