Introduction

Converting NSData to a string is simple when the bytes actually represent text and you know the encoding. The real issue is not the API call itself; it is choosing the right encoding and understanding that some binary data cannot be meaningfully turned into human-readable text at all.

NSData and Data in Modern Swift

In modern Swift, you usually work with Data rather than NSData. The two types bridge easily, but Data is the preferred Swift-native type.

If you already have Data, the standard conversion looks like this:

1import Foundation
2
3let data = Data("Hello, world!".utf8)
4
5if let text = String(data: data, encoding: .utf8) {
6    print(text)
7} else {
8    print("Could not decode data")
9}

This succeeds because the bytes were created as UTF-8 text.

If your value is NSData, convert or bridge it first:

1import Foundation
2
3let nsData: NSData = "Hello from NSData".data(using: .utf8)! as NSData
4let data = nsData as Data
5
6if let text = String(data: data, encoding: .utf8) {
7    print(text)
8}

Why Encoding Matters

The conversion API does not "guess" the correct text encoding reliably. You must supply one that matches the original bytes. UTF-8 is common, but not universal.

Example with UTF-16:

1import Foundation
2
3let original = "Swift"
4let utf16Data = original.data(using: .utf16)!
5
6print(String(data: utf16Data, encoding: .utf16) ?? "failed")
7print(String(data: utf16Data, encoding: .utf8) ?? "failed")

The first line prints the original text. The second fails because the bytes are decoded with the wrong encoding.

That is why "convert data to string" is really shorthand for "decode bytes using the correct text encoding."

Handling Network and File Data

A common use case is reading data from an API response or a file. If the content is JSON or plain text, UTF-8 is usually a good first choice.

1import Foundation
2
3let jsonBytes = """
4{"status":"ok","message":"ready"}
5""".data(using: .utf8)!
6
7if let jsonText = String(data: jsonBytes, encoding: .utf8) {
8    print(jsonText)
9}

But if the data represents an image, a compressed archive, or encrypted bytes, converting to String is the wrong operation. In those cases, use binary-safe representations such as:

• Base64 if you need a textual transport format
• hex if you need debugging output
• direct binary parsing if you need the underlying values

For example, Base64 is appropriate for arbitrary binary payloads:

1import Foundation
2
3let bytes = Data([0, 159, 255, 10])
4let base64 = bytes.base64EncodedString()
5print(base64)

That gives you text, but it is encoded binary text, not the original content interpreted as human-readable characters.

Bridging Back to Objective-C APIs

Some older APIs still return NSData. The conversion pattern is the same because Foundation bridges the types seamlessly.

1import Foundation
2
3func decode(_ payload: NSData) -> String? {
4    String(data: payload as Data, encoding: .utf8)
5}
6
7let payload: NSData = Data("bridge".utf8) as NSData
8print(decode(payload) ?? "nil")

This lets you keep modern Swift code while still interoperating with Objective-C-based libraries.

Common Pitfalls

The most common mistake is assuming all data is text. If the bytes come from an image or a PDF, String(data:encoding:) may return nil or meaningless output because the payload is not text.

Another mistake is using the wrong encoding. If a server sends UTF-16, ISO-8859-1, or some legacy encoding, decoding with .utf8 fails even though the data is valid.

A third issue is force-unwrapping the result. The string initializer is failable for a reason. If the bytes do not match the encoding, your conversion may return nil.

Finally, developers sometimes debug binary data by converting it straight to a string. For diagnostics, Base64 or hex is usually safer because it preserves every byte.

Summary

• In modern Swift, convert Data to String with String(data:encoding:).
• 'NSData can be bridged to Data and decoded the same way.'
• The correct text encoding matters; UTF-8 is common but not guaranteed.
• Not all binary data should be converted to a normal string.
• Use Base64 or hex when you need a textual representation of non-text bytes.