Introduction

On iOS 7, Base64 decoding no longer requires a custom third-party helper for normal cases. Foundation already provides the decoding API through NSData, so the main job is decoding the string and then interpreting the resulting bytes correctly.

That second step matters because Base64 decoding does not magically produce text. It produces raw bytes, and you decide whether those bytes represent a UTF-8 string, an image, or some other binary payload.

Decode Base64 With NSData

The standard Objective-C entry point on iOS 7 is initWithBase64EncodedString:options:.

1NSString *base64String = @"SGVsbG8gaU9T";
2NSData *data = [[NSData alloc] initWithBase64EncodedString:base64String options:0];
3
4NSString *text = [[NSString alloc] initWithData:data
5                                       encoding:NSUTF8StringEncoding];
6
7NSLog(@"%@", text);

If the input is valid Base64 that encodes UTF-8 text, this prints Hello iOS. For many app tasks, that is all you need.

Remember That Decoding Returns Bytes

A frequent misunderstanding is expecting Base64 decoding to return a string directly. The Base64 layer only reverses the text-safe encoding and gives you bytes back. How you use those bytes depends on the original content.

For text, convert the NSData into NSString. For an image, create a UIImage:

NSString *base64Image = @"...";
NSData *imageData = [[NSData alloc] initWithBase64EncodedString:base64Image options:0];
UIImage *image = [UIImage imageWithData:imageData];

If the original payload was arbitrary binary data, you may keep it as NSData and write it to disk or pass it to another API.

Handle Invalid Input Safely

If the string is malformed, the initializer returns nil. That means Base64 from external APIs, user input, or copied text should always be checked before use.

1NSData *decoded = [[NSData alloc] initWithBase64EncodedString:userInput options:0];
2if (!decoded) {
3    NSLog(@"Invalid Base64 input");
4    return;
5}

This small check is important because decoding failures often show up later as unrelated-looking string or image errors if you ignore the nil at the source.

Ignore Formatting Noise Only When Necessary

Some Base64 payloads include line breaks or other non-Base64 characters from transport formatting. In those cases, NSDataBase64DecodingIgnoreUnknownCharacters can help:

NSData *decoded = [[NSData alloc] initWithBase64EncodedString:base64String
                                                      options:NSDataBase64DecodingIgnoreUnknownCharacters];

Use this carefully. It is good for known formatting noise, but it can also hide bad upstream data if you apply it blindly.

Watch For URL-Safe Base64 Variants

Not every Base64 string uses the standard alphabet. Some systems use the URL-safe variant, which replaces + and / with - and _. If that is the case, normalize the string before decoding with the standard Foundation API.

1NSString *normalized = [[base64String stringByReplacingOccurrencesOfString:@"-" withString:@"+"]
2                        stringByReplacingOccurrencesOfString:@"_" withString:@"/"];
3
4NSData *decoded = [[NSData alloc] initWithBase64EncodedString:normalized options:0];

Only do this when you know the source format expects URL-safe Base64. Otherwise you risk changing valid input unnecessarily.

The Modern Swift Equivalent

The title is about iOS 7, but many codebases mixing old concepts and new syntax are easier to understand if you also know the modern Swift equivalent:

1import Foundation
2
3let base64 = "SGVsbG8gaU9T"
4if let data = Data(base64Encoded: base64),
5   let text = String(data: data, encoding: .utf8) {
6    print(text)
7}

The idea is the same as the Objective-C API: decode to bytes first, then interpret the bytes.

Common Pitfalls

One common mistake is assuming Base64 decoding returns a human-readable string automatically. It does not. Another is forgetting to validate the result before building an NSString or UIImage. Developers also sometimes use the "ignore unknown characters" option to paper over genuinely malformed input, which makes later debugging harder. Finally, Base64 payloads can be large, so keep memory usage in mind if the app holds both the original string and the decoded bytes at once.

Summary

• On iOS 7, use Foundation's built-in NSData Base64 decoder.
• Decoding returns raw bytes, not automatically a string or image.
• Validate the NSData result before using it.
• Use the ignore-unknown-characters option only for known formatting noise.
• Normalize URL-safe Base64 only when the upstream format actually requires it.