Core NFC

Enabling NFC in Your App

NFC reading requires adding the NFC Tag Reading entitlement and the NFCReaderUsageDescription key to your Info.plist.

1. Enable NFC Tag Reading capability in Xcode
2. Add NFCReaderUsageDescription to Info.plist

NFC Capabilities on iOS

iOS supports reading NFC tags in the following formats:

• NDEF (NFC Data Exchange Format)
• ISO 7816
• ISO 15693
• FeliCa
• MIFARE

Core NFC Framework

Import CoreNFC to access NFC reading APIs.

import CoreNFC

class NFCHandler: NSObject, NFCNDEFReaderSessionDelegate {
    var session: NFCNDEFReaderSession?
    
    func beginScanning() {
        guard NFCNDEFReaderSession.readingAvailable else {
            print("NFC not available on this device")
            return
        }
        session = NFCNDEFReaderSession(delegate: self, queue: nil, invalidateAfterFirstRead: false)
        session?.alertMessage = "Hold your iPhone near an NFC tag."
        session?.begin()
    }
    
    func readerSession(_ session: NFCNDEFReaderSession, didDetect tags: [NFCTag]) {
        // Handle detected tags
    }
    
    func readerSession(_ session: NFCNDEFReaderSession, didInvalidateWithError error: Error) {
        print("Session invalidated: \(error.localizedDescription)")
    }
}

NFCNDEFReaderSession

Read NDEF-formatted tags which are the most common NFC tag type.

import CoreNFC

class NDEFReader: NSObject, NFCNDEFReaderSessionDelegate {
    var onMessageRead: ((NFCNDEFMessage) -> Void)?
    
    func scan() {
        let session = NFCNDEFReaderSession(delegate: self, queue: nil, invalidateAfterFirstRead: true)
        session?.alertMessage = "Scan an NFC tag"
        session?.begin()
    }
    
    func readerSession(_ session: NFCNDEFReaderSession, didDetectNDEFs messages: [NFCNDEFMessage]) {
        for message in messages {
            for record in message.records {
                processRecord(record)
            }
        }
    }
    
    func processRecord(_ record: NFCNDEFPayload) {
        let type = record.type
        let payload = record.payload
        let decoded = String(data: payload, encoding: .utf8) ?? ""
        
        print("Type: \(type)")
        print("Payload: \(decoded)")
        
        // Parse well-known types
        if record.typeNameFormat == .nfcWellKnown {
            if let uri = record.wellKnownTypeURIPayload() {
                print("URI: \(uri.absoluteString)")
            }
            if let text = record.wellKnownTypeTextPayload(nil, nil) {
                print("Text: \(text)")
            }
        }
    }
}

Parsing NDEF Records

NDEF records contain typed data payloads. Common types include:

• Text: UTF-8 encoded text with language code
• URI: Web links, phone numbers, emails
• Smart Poster: Combined URI with title and icon

func parseNDEFPayload(_ payload: NFCNDEFPayload) -> NDEFData {
    guard payload.typeNameFormat == .nfcWellKnown else {
        return .unknown(payload)
    }
    
    // Check for URI record
    if let uri = payload.wellKnownTypeURIPayload() {
        return .uri(uri)
    }
    
    // Check for text record
    if let (text, language) = payload.wellKnownTypeTextPayload(nil, nil) {
        return .text(text: text, language: language ?? "en")
    }
    
    return .unknown(payload)
}

enum NDEFData {
    case uri(URL)
    case text(text: String, language: String)
    case unknown(NFCNDEFPayload)
}

Common NFC Applications

NFC technology enables various use cases in iOS apps:

• Contactless payments - Apple Pay integration
• Asset tracking - Tag equipment and inventory
• Smart posters - Interactive marketing materials
• Authentication - Access control and verification
• Product information - Link to digital content

Reading Specific Tag Types

CoreNFC supports reading different NFC standards.

import CoreNFC

class TagReader: NSObject, NFCTagReaderSessionDelegate {
    func scanForISO7816() {
        let session = NFCTagReaderSession(pollingOption: .iso14443, delegate: self)
        session?.alertMessage = "Hold near an ISO 14443 tag"
        session?.begin()
    }
    
    func tagReaderSession(_ session: NFCTagReaderSession, didDetect tags: [NFCTag]) {
        guard let tag = tags.first else { return }
        
        switch tag {
        case .iso7816(let iso7816Tag):
            // Read ISO 7816 tag data
            print("ISO 7816 tag detected")
        case .miFare(let miFareTag):
            // Read MIFARE tag data
            print("MIFARE tag detected")
        case .iso15693(let iso15693Tag):
            // Read ISO 15693 tag data
            print("ISO 15693 tag detected")
        case .feliCa(let feliCaTag):
            // Read FeliCa tag data
            print("FeliCa tag detected")
        @unknown default:
            break
        }
    }
}

Best Practices

• Always check NFCNDEFReaderSession.readingAvailable before scanning
• Provide clear user feedback with alert messages
• Handle session invalidation gracefully
• Test with real NFC tags during development
• Consider using external NFC readers for advanced use cases

Limitations

• iOS does not support writing to NFC tags (read-only)
• Background NFC reading requires Core NFC background mode
• Only one NFC session can be active at a time
• Some tag types require specific entitlements