How to Check Type at Runtime in Kotlin: instanceof, is, and Smart Casts

By the end of this page, you will understand how Kotlin checks an object's type at runtime using is and !is, how smart casts work after a successful type check, and when to use when for handling multiple possible types. You will also see common mistakes, practical examples, and how this pattern is used in real Kotlin code.

Kotlin does not use the Java keyword instanceof. Instead, Kotlin uses the is operator for runtime type checks.

For example:

if (value is String) {
    println("This is a String")
}

This checks whether value is an instance of String at runtime.

Kotlin also provides !is, which means “is not of this type”:

if (value !is String) {
    println("This is not a String")
}

Why this matters

In real programs, you often receive values whose exact type is not known in advance:

• function parameters typed as Any
• API responses mapped into different models
• sealed class hierarchies
• event systems
• error objects

Runtime type checking lets you safely decide what to do based on the actual object type.

A key Kotlin feature: smart casts

One major improvement over Java is that after checking with is, Kotlin can automatically treat the variable as that type inside the safe branch. This is called a smart cast.

  {
     (value  String) {
        println(value.length)
    }
}

Think of is as checking a label on a package before opening it.

• Any means “this is some package, but we do not yet know what is inside.”
• is String means “check whether the package is labeled String.”
• If the label matches, Kotlin lets you open it as that type automatically.

So instead of saying, “I know this is probably a String, let me cast it,” Kotlin says, “First verify the label, then I will safely treat it as a String for you.”

That automatic trust after the check is the smart cast.

Basic syntax

if (value is String) {
    println("value is a String")
}

if (value !is String) {
    println("value is not a String")
}

Example with Any

fun describe(value: Any) {
    if (value is Int) {
        println("Integer: $value")
    } else if (value is String) {
        println("String with length ${value.length}")
    } else {
        println("Unknown type")
    }
}

Explanation

• value is declared as Any, so it can hold values of many types.
• value is Int checks whether the runtime object is an Int.
• value is String checks whether it is a .

Consider this example:

fun printInfo(value: Any) {
    if (value is String) {
        println("Text: ${value.uppercase()}")
    } else {
        println("Not a string")
    }
}

fun main() {
    printInfo("kotlin")
    printInfo(42)
}

Step by step

First call: printInfo("kotlin")

1. The argument is the string "kotlin".
2. Inside printInfo, value has declared type Any.
3. Kotlin evaluates value is String.
4. The check is true.
5. Kotlin smart casts value to String inside the if block.
6. value.uppercase() runs and produces .

1. Handling mixed input values

A function may receive values from different sources:

fun logValue(value: Any) {
    when (value) {
        is String -> println("Message: $value")
        is Int -> println("Count: $value")
        is Boolean -> println("Enabled: $value")
    }
}

2. Working with API or parsing results

After parsing data, the result may be one of several model types:

when (result) {
    is Success -> println(result.data)
    is Error -> println(result.message)
}

3. UI event handling

Applications often process different event objects:

when (event) {
    is ClickEvent -> handleClick(event)
    is ScrollEvent -> handleScroll(event)
}

4. Error handling

You may inspect exception types:

In real Kotlin projects, developers often use type checks in a few common patterns.

Guard clauses

Exit early if a value is not the expected type:

fun process(value: Any) {
    if (value !is String) return
    println(value.length)
}

This keeps the rest of the function clean.

when for branching by type

fun render(item: Any) {
    when (item) {
        is String -> println(item)
        is Int -> println(item * 2)
        else -> println("Unsupported")
    }
}

Validation before using data

fun save(input: Any) {
    require(input is String) { "Input must be a String" }
    println(input.length)
}

Working with interfaces and polymorphism

1. Using instanceof in Kotlin

This is Java syntax, not Kotlin syntax.

Wrong

if (value instanceof String) {
    println(value)
}

Correct

if (value is String) {
    println(value)
}

2. Using Object instead of Any

In Kotlin, the usual root type is Any, not Java's Object.

Better

fun process(value: Any) {
    println(value)
}

3. Forgetting about nullability

Any cannot hold null. Use Any? if null is possible.

 {
     (value  String) {
        println(value.length)
    }
}

is vs Java instanceof

is vs as

Runtime type checking in Kotlin

if (value is String) { }
if (value !is String) { }

Smart cast

if (value is String) {
    println(value.length)
}

After a successful is check, Kotlin often smart casts the value.

Multiple types with when

when (value) {
    is String -> println(value.length)
    is Int -> println(value)
    else -> println("Unknown")
}

Safe cast

val text = value as? String
println(text?.length)

Force cast

val text = value as String

Use carefully: this throws an exception if the type is wrong.

Root object types

What is the Kotlin equivalent of instanceof?

Use the is operator.

if (value is String) {
    println("It is a String")
}

How do I check that an object is not a type in Kotlin?

Use !is.

if (value !is String) {
    println("It is not a String")
}

What type should I use instead of Java Object in Kotlin?

Use Any for non-null values and Any? if null is allowed.

Does is also match subclasses?

Yes. If an object is an instance of a subclass, is returns true for the parent type or implemented interface.

Do I need to cast after using is?

Usually no. Kotlin often smart casts automatically inside the checked branch.

What is the difference between and in Kotlin?

Any

The Kotlin root type for non-null objects. It is commonly used when a function can accept different kinds of values.

Null safety

Important because Any and Any? behave differently when null is involved.

Smart casts

Directly related because Kotlin automatically narrows the type after an is check.

Type casting

Useful alongside type checks when you need as or as?.

when expression

Often used to branch on multiple runtime types in a readable way.

Inheritance and interfaces

Relevant because is works with parent classes, subclasses, and interface implementations.

Sealed classes

A cleaner alternative in many designs where a value can be one of a fixed set of types.