How to Convert String to Long in Kotlin

By the end of this page, you will understand how Kotlin converts strings into Long values, when to use toLong() versus toLongOrNull(), what happens with invalid input, and how this is typically handled in real Kotlin code.

Kotlin uses extension functions for many common conversions instead of relying on Java-style static utility methods such as Long.valueOf(...).

For converting a String to a Long, the two most important functions are:

• toLong()
• toLongOrNull()

toLong()

This converts the string directly to a Long.

val id = "123".toLong()

If the string is not a valid number, Kotlin throws an exception:

• NumberFormatException

toLongOrNull()

This tries to convert the string, but instead of throwing an exception, it returns null if conversion fails.

val id = "123".toLongOrNull()

This is often the safer choice when input comes from users, files, APIs, or forms.

Why this matters

In real programs, numeric values often arrive as text:

• query parameters from URLs

Think of a String as a label containing text, and a Long as a large-number container.

When you call toLong(), you are asking Kotlin:

"Please read this text and turn it into a whole number."

If the text really looks like a number, the conversion works. If the text contains anything unexpected, the conversion fails.

• "42" -> works
• "9999999999" -> works
• "hello" -> fails
• "12.5" -> fails because that is not a whole number

toLongOrNull() is like asking:

"Try to read this as a whole number, and if you can't, just give me null instead of crashing."

That makes it much easier to handle uncertain input safely.

Basic syntax

val number: Long = "123".toLong()
val maybeNumber: Long? = "123".toLongOrNull()

Example: direct conversion

fun main() {
    val text = "456"
    val value = text.toLong()

    println(value)
}

Output:

456

Here, text contains a valid whole number, so toLong() succeeds.

Example: safe conversion

fun main() {
    val text = "abc"
    val value = text.toLongOrNull()

    println(value)
}

Output:

null

Consider this example:

fun main() {
    val input = "2048"
    val number = input.toLongOrNull()

    if (number != null) {
        println(number + 1)
    } else {
        println("Invalid input")
    }
}

Step by step

1. input is assigned the string "2048".
2. input.toLongOrNull() tries to parse the text as a Long.
3. Because "2048" is a valid whole number, the result is 2048L.
4. number now holds a non-null Long value.
5. The condition number != null is true.
6. Kotlin runs println(number + 1).
7. The output is 2049.

Now look at invalid input:

String-to-Long conversion appears in many real programs.

User input

A user types an ID, age, timestamp, or quantity into a form.

val userId = input.toLongOrNull()

URL and API parameters

A backend service may receive IDs as strings.

val idFromRequest = params["id"]?.toLongOrNull()

Reading CSV or text files

Data files often store numeric values as text.

val columns = line.split(",")
val orderId = columns[0].toLongOrNull()

Database integration

Some systems return values as strings before conversion.

val externalId = rawValue.toLongOrNull()

Command-line tools

Arguments passed to a Kotlin script or app are strings.

val timeout = args.firstOrNull()?.toLongOrNull()

In real Kotlin codebases, developers usually prefer safe parsing when input is external.

Pattern: validation first

val id = input.toLongOrNull()
if (id == null) {
    println("Invalid ID")
    return
}

println("Processing ID $id")

This is a common guard clause pattern: reject bad input early.

Pattern: default value

val pageSize = input.toLongOrNull() ?: 10L

If parsing fails, the code uses a fallback value.

Pattern: nullable pipeline

val result = input
    .trim()
    .toLongOrNull()

This is common when cleaning user input before conversion.

Pattern: fail fast for trusted data

val configValue = envVar.toLong()

If the program expects valid numeric configuration and invalid data should stop execution, toLong() may be appropriate.

Pattern: mapping collections

1. Using toLong() on untrusted input

Broken example:

val input = "abc"
val number = input.toLong() // Throws NumberFormatException

Why it fails:

• "abc" is not a valid whole number.
• toLong() throws an exception.

Better:

val number = input.toLongOrNull()

2. Forgetting that toLongOrNull() returns a nullable type

Broken example:

val number: Long = "123".toLongOrNull()

Why it fails:

• toLongOrNull() returns Long?, not Long.

Better:

 number: ? = .toLongOrNull()

Quick reference

val n1 = "123".toLong()          // Long
val n2 = "123".toLongOrNull()    // Long?

Safe parsing

val value = input.toLongOrNull()
if (value != null) {
    println(value)
}

With default value

val value = input.toLongOrNull() ?: 0L

Trim input first

val value = input.trim().toLongOrNull()

Important rules

• toLong() throws if parsing fails.
• toLongOrNull() returns null if parsing fails.
• Long is for whole numbers, not decimals.
• toLongOrNull() returns Long?, so handle nullability.
• Use suffix for literals, for example .

How do I convert a String to Long in Kotlin?

Use toLong() if the string is definitely valid, or toLongOrNull() if it may be invalid.

What is the Kotlin equivalent of Long.valueOf()?

The idiomatic Kotlin equivalent is "123".toLong() or "123".toLongOrNull().

What happens if the string is not a valid number?

toLong() throws NumberFormatException, while toLongOrNull() returns null.

Should I use toLong() or toLongOrNull()?

Use toLongOrNull() for user input, API data, or files. Use toLong() when the input is trusted and should always be valid.

Can I convert decimal text like "12.5" to Long?

No. Long only stores whole numbers. Use toDouble() or toDoubleOrNull() for decimal values.

• String to Int conversion - Similar numeric parsing, but for smaller integer values.
• String to Double conversion - Used when the input may contain decimals.
• Null safety in Kotlin - Important because toLongOrNull() returns a nullable type.
• Extension functions in Kotlin - Explains why Kotlin uses toLong() instead of Java-style static methods.
• Exception handling in Kotlin - Useful for understanding what happens when toLong() fails.
• Type inference in Kotlin - Helps explain how Kotlin determines variable types during conversions.