How to convert a string to an int in Go

1strconv.AtoiRecommended

strconv.Atoi(s) ("ASCII to integer" — the name is C heritage) parses a plain base-10 integer into an int. It is shorthand for ParseInt(s, 10, 0) and it is the right call for the common case. The error is not optional decoration: anything that isn't exactly an integer — letters, decimals, empty string — comes back as a non-nil err instead of a panic or a silent zero.

package main

import (
	"fmt"
	"strconv"
)

func main() {
	n, err := strconv.Atoi("42")
	if err != nil {
		fmt.Println("conversion failed:", err)
		return
	}
	fmt.Println(n + 1) // it's a real int now

	// Atoi rejects anything that isn't a plain base-10 integer
	_, err = strconv.Atoi("42abc")
	fmt.Println(err)
}

Prints 43 — the arithmetic proves it's an int, not a string — then strconv.Atoi: parsing "42abc": invalid syntax. Note the error message quotes the offending input for you, which makes these errors unusually easy to debug in logs.

2ParseInt: bases and bit sizes

strconv.ParseInt(s, base, bitSize) is the general form. base is 2 to 36 (or 0 to auto-detect from a 0x/0b/0o prefix), and bitSize says what the value must fit in — 8, 16, 32, or 64. It always returns an int64; bitSize only controls the range check, so converting down to int8(n) afterwards is safe when you asked for 8. There's a ParseUint twin for unsigned values.

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// base 10, 64-bit -- ParseInt always returns an int64
	n, _ := strconv.ParseInt("-128", 10, 64)
	fmt.Println(n)

	// other bases: hex and binary
	hex, _ := strconv.ParseInt("ff", 16, 64)
	bin, _ := strconv.ParseInt("1010", 2, 64)
	fmt.Println(hex, bin)

	// base 0 reads the prefix for you: 0x, 0b, 0o, or plain decimal
	auto, _ := strconv.ParseInt("0xff", 0, 64)
	fmt.Println(auto)

	// bitSize guards the range: 300 does not fit in an int8
	_, err := strconv.ParseInt("300", 10, 8)
	fmt.Println(err)
}

Prints -128, then 255 10, then 255 again from the auto-detected 0x prefix, and finally strconv.ParseInt: parsing "300": value out of range — the string is a perfectly valid integer, it just doesn't fit in 8 bits. With base 16 the 0x prefix must be omitted; only base 0 accepts it.

3Decimal strings: ParseFloat, then convert

Atoi("3.99") fails — a decimal point is a syntax error to an integer parser. If the string can legitimately carry a fraction, parse it as a float first, then decide how it becomes an int: int(f) truncates toward zero, and math.Round rounds to nearest. That's a real decision, not a formality — prices, percentages, and quantities each want a different one.

package main

import (
	"fmt"
	"math"
	"strconv"
)

func main() {
	// Atoi refuses decimals -- "3.99" is not an integer
	_, err := strconv.Atoi("3.99")
	fmt.Println(err)

	// Parse as a float first, then decide how to make it an int
	f, err := strconv.ParseFloat("3.99", 64)
	if err != nil {
		fmt.Println("not a number:", err)
		return
	}
	fmt.Println(int(f))             // truncates toward zero
	fmt.Println(int(math.Round(f))) // rounds to nearest
}

Prints the invalid syntax error first, then 3 (truncated) and 4 (rounded). Watch negatives: truncation goes toward zero, so int(-3.99) is -3, not -4 — a classic off-by-one in billing code.

4Real-world input: trim, check, keep going

Input from files, prompts, and HTTP forms arrives with whitespace attached — bufio readers in particular hand you the trailing newline, and Atoi("42\n") fails. The fix is a tiny helper that trims first. The same pattern scales to batches: convert each value, skip and report the bad ones, and keep the good ones instead of aborting the lot.

package main

import (
	"fmt"
	"strconv"
	"strings"
)

// toInt trims whitespace (including newlines from user input) before parsing.
func toInt(s string) (int, error) {
	return strconv.Atoi(strings.TrimSpace(s))
}

func main() {
	n, err := toInt("  42\n")
	fmt.Println(n, err)

	// Real-world loop: keep the good values, report the bad ones
	raw := []string{"10", " 20 ", "x", "30"}
	total := 0
	for _, s := range raw {
		n, err := toInt(s)
		if err != nil {
			fmt.Println("skipping", strconv.Quote(s), "->", err)
			continue
		}
		total += n
	}
	fmt.Println("total:", total)
}

Prints 42 <nil>, then skipping "x" -> strconv.Atoi: parsing "x": invalid syntax, then total: 60. strconv.Quote in the log line is a small habit worth copying — it makes invisible characters (the very thing that broke the parse) visible.

5Which should you use?

6Pull numbers out of formatted text

When the integer is embedded in a known layout, fmt.Sscanf parses the whole line in one call — it's Scanf reading from a string instead of stdin. You pass a format string and pointers; it fills them and returns how many it matched plus an error. For anything less rigid than a fixed format, split the string or use a regexp and Atoi the pieces instead.

package main

import "fmt"

func main() {
	var day, year int
	var month string
	_, err := fmt.Sscanf("Jul 24, 2026", "%s %d, %d", &month, &day, &year)
	if err != nil {
		fmt.Println("scan failed:", err)
		return
	}
	fmt.Println(day, month, year)
}

Prints 24 Jul 2026 — one call parsed two ints and a word. %s stops at whitespace, which is what makes the layout above work; it also means Sscanf is brittle when the format drifts, so keep it for input you control.

7What happens on overflow

Two different things can go wrong in a parse, and Go distinguishes them: ErrSyntax (not a number at all) and ErrRange (a valid number that doesn't fit). On a range error the returned value isn't garbage — it's clamped to the nearest representable value — but you should treat it as unusable unless you've specifically decided saturation is what you want. errors.Is tells the two cases apart.

package main

import (
	"errors"
	"fmt"
	"strconv"
)

func main() {
	n, err := strconv.Atoi("99999999999999999999")
	fmt.Println(n)
	fmt.Println(err)
	fmt.Println(errors.Is(err, strconv.ErrRange))
}

Prints 9223372036854775807 — the max int64, the clamp in action — then strconv.Atoi: parsing "99999999999999999999": value out of range and true. If values this large are legitimate in your domain, parse into math/big.Int with SetString instead of an int.