When an API uses an abstract base class, the (only) way to provide a version of that API is to subclass the abstract base class.
Because in C# and Java we can only have one super class, it is, in some sense, a scarce resource. Requiring that each API implementer subclass from that abstract base class means they cannot subclass from a class of their choice. (This means the subclass will then have be a new class for each implementer, and that will likely have to act as a proxy to another class in the their hierarchy.)
When an API uses an interface, each implementer may choose any base class they desire. This means, for example, that they can implement the interface from an existing class in their class hierarchy.
Thus, interfaces result in looser coupling (among class hierarchies) and more implementation freedom.
(There are further things to say about tighter coupling if the abstract class provides any implementation, e.g. anything beyond the abstract method).