diff --git a/src/main/java/io/netty/buffer/api/Deref.java b/src/main/java/io/netty/buffer/api/Deref.java
index 7dd206e..4a1e7b7 100644
--- a/src/main/java/io/netty/buffer/api/Deref.java
+++ b/src/main/java/io/netty/buffer/api/Deref.java
@@ -48,5 +48,5 @@ public interface Deref<T extends Rc<T>> extends Supplier<T> {
      * @param cls The type to check.
      * @return {@code true} if the object in this {@code Deref} can be assigned fields or variables of the given type.
      */
-    boolean isInstanceOf(Class<?> cls);
+    boolean referentIsInstanceOf(Class<?> cls);
 }
diff --git a/src/main/java/io/netty/buffer/api/Rc.java b/src/main/java/io/netty/buffer/api/Rc.java
index beec593..c445cf9 100644
--- a/src/main/java/io/netty/buffer/api/Rc.java
+++ b/src/main/java/io/netty/buffer/api/Rc.java
@@ -42,7 +42,7 @@ public interface Rc<I extends Rc<I>> extends AutoCloseable, Deref<I> {
     }
 
     @Override
-    default boolean isInstanceOf(Class<?> cls) {
+    default boolean referentIsInstanceOf(Class<?> cls) {
         return cls.isInstance(this);
     }
 
diff --git a/src/main/java/io/netty/buffer/api/Send.java b/src/main/java/io/netty/buffer/api/Send.java
index b272740..005c9c5 100644
--- a/src/main/java/io/netty/buffer/api/Send.java
+++ b/src/main/java/io/netty/buffer/api/Send.java
@@ -56,7 +56,7 @@ public interface Send<T extends Rc<T>> extends Deref<T> {
             }
 
             @Override
-            public boolean isInstanceOf(Class<?> cls) {
+            public boolean referentIsInstanceOf(Class<?> cls) {
                 return cls.isAssignableFrom(concreteObjectType);
             }
 
@@ -69,6 +69,19 @@ public interface Send<T extends Rc<T>> extends Deref<T> {
         };
     }
 
+    /**
+     * Determine if the given candidate object is an instance of a {@link Send} from which an object of the given type
+     * can be received.
+     *
+     * @param type The type of object we wish to receive.
+     * @param candidate The candidate object that might be a {@link Send} of an object of the given type.
+     * @return {@code true} if the candidate object is a {@link Send} that would deliver an object of the given type,
+     * otherwise {@code false}.
+     */
+    static boolean isSendOf(Class<?> type, Object candidate) {
+        return candidate instanceof Send && ((Send<?>) candidate).referentIsInstanceOf(type);
+    }
+
     /**
      * Receive the {@link Rc} instance being sent, and bind its ownership to the calling thread. The invalidation of the
      * sent Rc in the sending thread happens-before the return of this method.
diff --git a/src/main/java/io/netty/buffer/api/TransferSend.java b/src/main/java/io/netty/buffer/api/TransferSend.java
index b6d115c..a7cc7e7 100644
--- a/src/main/java/io/netty/buffer/api/TransferSend.java
+++ b/src/main/java/io/netty/buffer/api/TransferSend.java
@@ -55,7 +55,7 @@ class TransferSend<I extends Rc<I>, T extends Rc<I>> implements Send<I> {
     }
 
     @Override
-    public boolean isInstanceOf(Class<?> cls) {
+    public boolean referentIsInstanceOf(Class<?> cls) {
         return cls.isAssignableFrom(concreteType);
     }
 
diff --git a/src/test/java/io/netty/buffer/api/BufferSendTest.java b/src/test/java/io/netty/buffer/api/BufferSendTest.java
index b287900..d4a4591 100644
--- a/src/test/java/io/netty/buffer/api/BufferSendTest.java
+++ b/src/test/java/io/netty/buffer/api/BufferSendTest.java
@@ -15,6 +15,7 @@
  */
 package io.netty.buffer.api;
 
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -131,4 +132,26 @@ public class BufferSendTest extends BufferTestSupport {
             assertEquals(72, bifB.readInt());
         }
     }
+
+    @Test
+    public void isSendOfMustCheckObjectTypes() {
+        try (BufferAllocator allocator = BufferAllocator.heap()) {
+            Send<Buffer> bufferSend = allocator.allocate(8).send();
+            Send<BufferRef> bufferRefSend = new BufferRef(allocator.allocate(8).send()).send();
+            try {
+                assertTrue(Send.isSendOf(Buffer.class, bufferSend));
+                assertFalse(Send.isSendOf(BufferRef.class, bufferSend));
+                assertFalse(Send.isSendOf(Buffer.class, bufferRefSend));
+                assertTrue(Send.isSendOf(BufferRef.class, bufferRefSend));
+                assertFalse(Send.isSendOf(Buffer.class, new Object()));
+                assertFalse(Send.isSendOf(Object.class, new Object()));
+            } finally {
+                bufferSend.discard();
+                bufferRefSend.discard();
+            }
+            // Type checks must still pass after the sends have been received.
+            assertTrue(Send.isSendOf(Buffer.class, bufferSend));
+            assertTrue(Send.isSendOf(BufferRef.class, bufferRefSend));
+        }
+    }
 }