Programming NFC Tags with iPhone

iPhone NFC hardware and iOS compatibility matrix — what each iPhone can do

For years an iPhone could read an NFC tag but flatly refused to write one — Apple shipped the antenna first and then doled out permission to use it across a long, cautious sequence of iOS releases. That history is exactly why iPhone NFC needs a compatibility matrix rather than a single sentence: what a phone can actually do depends on which model it is and which version it runs. Apple rolled out NFC capability gradually across iPhone generations and iOS versions, with capabilities unlocking per generation. Understanding the compatibility matrix is the first step for anyone planning an NFC programme that needs to reach iPhone users, whether as a consumer experience or as an employee-facing workflow.

• iPhone 6 and earlier. No NFC hardware or only Apple Pay restricted hardware. These devices cannot interact with third-party NFC tags in any way. A small number of consumer programmes still encounter iPhone 6 users in 2026, but most active iPhone users are on iPhone 8 or later.
• iPhone 7 / 8 / X. NFC hardware present, but restricted by iOS to read-only NDEF detection within apps (iOS 11+, requires the user to launch an NFC-capable app and confirm the read). These devices do NOT support iOS background NDEF URL detection — that capability is gated to iPhone XS and later by Apple's developer documentation. iPhone 7/8/X can trigger URL actions from tags only when the user is inside an explicit NFC-capable app, and cannot write to tags. Modest reach in 2026 because most active iPhone users have moved to iPhone 11 or later.
• iPhone XS / XR and later (XS, XR, 11, 12, 13, 14, 15, 16 series). Full Core NFC support: NDEF writing, tag UID reading, ISO 14443 Type A/B / ISO 15693 / FeliCa / MIFARE session access, and — critically — system-level background NDEF URL detection that fires when the phone is awake and unlocked even with no NFC app installed. These are the devices that can act as NFC tag writers using App Store apps and the substrate of essentially every consumer NFC programme in market.
• Background tag reading: introduced in iOS 13 alongside the rest of the read/write stack, available on iPhone XS, XS Max, XR and every later model. When the phone is awake and unlocked, iOS continuously listens for NDEF tags carrying URL records; on detection it surfaces a system notification banner that opens the URL in Safari (or via Universal Links into your installed app). No app needs to be open. This is the mechanism behind virtually every modern consumer iPhone NFC deployment — restaurant menus, product authentication, smart posters, Google Review cards, hotel-room engagement and Apple Wallet pass distribution.
• iPad NFC support: iPad devices generally do not include NFC hardware, with the exception of some enterprise-targeted tablets via external readers. iPhone is the Apple NFC platform; programmes requiring iPad NFC need to plan for external USB or Bluetooth NFC reader accessories.
• iOS version as a compatibility gate. iOS 13 is the minimum for full Core NFC writing AND for system-level background NDEF URL detection on iPhone XS+; iOS 14 added App Clip NFC invocations; iOS 15 added refined Shortcuts NFC automation; iOS 17.4 added Apple's CardSession host card emulation API for in-app contactless payments and tap-to-enter (initially restricted to banking/wallet apps in the European Economic Area under a special entitlement); iOS 18 / 18.1 expanded that surface to additional regions and use cases (loyalty, transit, identity, access). Consumer programmes in 2026 can safely target iOS 15+ as a baseline, with iOS 13+ as a fallback for long-tail device reach.
• Apple NFC controller silicon. iPhone XS through current generations integrate an NFC controller paired with the Apple-designed Secure Element (codename 'Stockholm') used by Apple Pay, Apple Wallet passes and — beginning with iOS 17.4 in the EEA and expanding via iOS 18.1 — third-party HCE through the new CardSession API. From a third-party app's perspective the Core NFC API is unchanged across hardware generations; the practical takeaway for tag programming is that any iPhone XS or later behaves identically for NDEF read/write, and HCE-style emulation is enabled by entitlement and OS version rather than by silicon generation.
• iPhone NFC antenna location per model. iPhone 7 through iPhone X: antenna runs along the top edge of the back glass; iPhone XS through iPhone 12: top-center behind the Apple logo; iPhone 13/14/15/16: still near the top but weighted slightly toward the upper third of the back. For consumer tap zones, signage should show 'tap top of phone against tag' rather than specifying exact coordinates. Apple's antenna engineering is forgiving enough that any position within the top third of the back works for most tag form factors.
• Accessibility and haptic feedback. iOS 15+ plays a brief haptic tap on successful NFC tag detection, helping users with visual impairments or loud environments confirm the tap registered. For commercial deployments where visual feedback is impractical (e.g., in-car CarPlay NFC taps), the haptic is the primary success signal. Apps using NFCNDEFReaderSession or NFCTagReaderSession can surface additional VoiceOver prompts during the session for full accessibility support.

Free App Store apps for NFC tag programming (no developer account required)

For customers programming NFC tags without writing any code (marketing teams, small business owners, hotel/restaurant operators, event planners) the App Store provides several free, well-maintained apps that handle the NDEF encoding, memory management and iPhone antenna interaction. This section surveys the apps most commonly used for iPhone-based NFC tag writing.

• NFC Tools (wakdev): the most popular free NFC writer on iOS. Supports writing URL, text, phone number, email, SMS, geolocation, Wi-Fi credentials (via custom MIME type), Bluetooth pairing, vCard, application launch and custom raw NDEF records. Read mode reveals tag chip type, memory size, UID and NDEF content. Provides a paid Pro tier with advanced features (lock, password, MIFARE DESFire support, batch operations).
• NXP TagWriter: official app from NXP, the manufacturer of NTAG and MIFARE chips. Optimized for NTAG 21x and NTAG 424 DNA programming with guided workflows. Strong support for NDEF Wi-Fi records, Bluetooth pairing and contact vCard. The app is free and trustworthy for programmes specifically using NXP-chip tags (which includes most NFC stickers in market).
• Simply NFC: clean, minimalist app focused on rapid URL and text encoding. Good choice for non-technical users who need a straightforward experience for programming hundreds of tags with the same URL template (e.g., restaurant menus per table). Some advanced features behind in-app purchases.
• NXP TagInfo: diagnostic-focused app that reads and dissects NFC tag content in detail (chip type, memory dump, NDEF record parsing, NFC Forum compliance validation). Free from NXP and valuable as a companion app for verifying programmed tags before deployment. Essential for QA workflows.
• GoToTags iOS: commercial app with strong enterprise focus, supporting batch programming, CSV import of tag content, and advanced NDEF record types. Used by customers programming thousands of tags from spreadsheet data without needing custom development.
• Walletmor / InfiniLink and other specialized apps. Additional apps for specific use cases (LinkedIn profile programming, social media link packs, Apple Wallet pass deployment on NFC). Typically free or freemium. Evaluate on a per-programme basis against the most-needed NDEF record types.

Step-by-step tag programming with iPhone — consumer workflow without code

Every first-time iPhone tag write includes the same small ritual: the slow, slightly self-conscious hunt for the exact spot on the back of the phone where the antenna actually lives. Find it once and the rest is genuinely easy. For users programming a batch of NFC stickers, cards or fobs with iPhone-only tools, the end-to-end workflow is consistent across the app landscape. This section walks through the typical process, along with the tips that improve first-attempt success rates and reduce waste on failed writes.

1. Step 1
   Step 1 — Pick the right tag and app for your data. URL and simple text fit easily on NTAG 213 (144 bytes). Longer URLs, vCards or multiple records need NTAG 215 (504 bytes) or NTAG 216 (888 bytes). For password-protected or authenticated tags, plan to use NTAG 424 DNA and an app that supports DNA programming (NXP TagWriter or NFC Tools Pro).
2. Step 2
   Step 2 — Open the writing app and select the NDEF record type. For URLs, use the URL record type (NFC Forum URI type, automatic prefix compression reduces memory use). For Wi-Fi credentials, use the Wi-Fi Simple Configuration NDEF record (recognized by iOS for one-tap Wi-Fi joining). For text content, use the Text NDEF record with the appropriate language code (en, zh-CN, etc.).
3. Step 3
   Step 3 — Enter your data with iOS character-encoding considerations in mind. URLs should be URL-encoded; text records handle UTF-8 natively; Wi-Fi passwords can include special characters but need to be entered exactly matching the router configuration. Many apps preview the NDEF byte count so you can verify the payload fits within the tag's memory budget.
4. Step 4
   Step 4 — Position the iPhone antenna over the tag for writing. The NFC antenna is at the top-center of the iPhone's back (note this is slightly different per-generation; on iPhone 15 Pro it's around the Apple logo area). Best-practice: align the top third of the iPhone back directly over the tag's antenna coil, press gently (phone-to-tag gap of 1-2 mm ideal), and hold still for 2-3 seconds.
5. Step 5
   Step 5 — Verify the write before moving on. The app will typically display a success message; then read the tag back to confirm the content. Bring the programmed tag into proximity of the iPhone (phone still awake/unlocked); for URL records, iOS should display the URL-open notification automatically, confirming the background NDEF detection path works end-to-end.
6. Step 6
   Step 6 — Optionally lock or password-protect the tag. NFC Forum Type 2 tags (NTAG 21x) support a one-way lock that permanently makes the tag read-only; NTAG 424 DNA supports password-protected writes. Locking prevents accidental overwrites in the field but makes future content updates impossible. For dynamic-content programmes (events, seasonal promotions), leave tags unlocked and rotate content on a scheduled basis.

iOS Shortcuts automation — per-tag NFC triggers without writing an app

iOS Shortcuts provides a powerful, code-free automation surface that can be triggered by a specific NFC tag. This is the mechanism behind many consumer iPhone NFC programmes that go beyond simple URL open. From smart-home routines to app-launch triggers to conditional content delivery.

• How iOS Shortcuts NFC automation works. In the Shortcuts app, create a new Personal Automation with NFC trigger type, scan the specific tag (by its unique UID) to bind the automation to that tag, then define the actions to run when the tag is detected (open URL, send message, set Do Not Disturb, run HomeKit scene, open app with specific state, run a custom Shortcut). Actions run automatically after a confirmation prompt (iOS 15+) or silently in earlier iOS versions.
• Use cases: bedside "goodnight" tag that dims lights, sets alarm and enables Do Not Disturb; car dashboard tag that starts navigation, opens Apple Music and launches CarPlay; office entry tag that silences notifications and opens Teams/Slack; bathroom "timer" tag; kitchen "recipe" tag. Shortcuts automation gives NFC a flexibility well beyond static NDEF URL records.
• NFC Shortcuts are per-device. Each iPhone user creates their own automation, bound to specific tag UIDs. This is different from NDEF-URL-based programmes where every iPhone sees the same URL when tapping the same tag. Shortcuts suit personal productivity and household automation; broad consumer programmes use NDEF URL records instead.
• Combining NDEF URL and Shortcuts. For programmes where iPhone users might want extra behavior when tapping a tag (e.g., marketing tag that both opens a product URL and adds a Shortcut-triggered notification), tags carry NDEF URL records for the default behavior, and users who want enhanced interactions add a personal Shortcut bound to the tag's UID. This layered approach works well for loyalty programmes, events and membership tags.
• Shortcuts NFC works on iPhone XS and later running iOS 13+, with automation-specific refinements in iOS 14 (silent run without confirmation for frequently used Shortcuts) and iOS 17 (refined prompt UI and background execution timing). Consumer programmes can assume Shortcuts availability on the overwhelming majority of active iPhones.
• Programming workflow considerations: Shortcuts automation is per-device, so the tag's UID is the binding key. For deployments where users move between iPhones or replace devices, the Shortcut needs to be re-created. The tag's NDEF content persists across all devices; the per-device Shortcut does not. Documentation and customer communication should clarify which layer delivers which behavior.

iOS developer path — Core NFC framework, NFCTagReaderSession, NDEFReaderSession, entitlements

For iOS app developers integrating NFC functionality into custom apps (loyalty programmes, luxury-authentication scanners, pharmaceutical traceability apps, access-control apps, enterprise field-service apps) Apple's Core NFC framework is the native integration surface. This section surveys the framework, the session types and the common implementation patterns.

• Core NFC framework overview. Introduced in iOS 11 (read-only NDEF), expanded in iOS 13 (full read/write, tag-level access to ISO 14443 and ISO 15693), refined across iOS 14-17 (better error handling, background invocation, Shortcut integration). The framework runs in an entitled foreground app with user-initiated session activation; Apple does not allow background continuous NFC reading for custom apps (background NDEF URL detection is a system-level behavior, not an app feature).
• NFCNDEFReaderSession: the simplest session type for apps that only need to read or write NDEF content. Invoke via `let session = NFCNDEFReaderSession(delegate: self, queue: nil, invalidateAfterFirstRead: true)`; session presents a system sheet to the user, reads/writes the tag, and invalidates. Good fit for consumer apps that need one-tap NFC interaction.
• NFCTagReaderSession: lower-level session for apps that need access to the raw tag interface. Supports polling options for ISO 14443 Type A/B (MIFARE, NTAG), ISO 15693 (ICODE, ST25), FeliCa (Sony Type F) and MIFARE Ultralight. Apps can send APDU commands directly to MIFARE DESFire for authenticated access, read NTAG 424 DNA SUN messages, or interact with contactless credit cards in ISO 14443-4 mode (subject to Apple's payment-interoperability restrictions).
• Entitlements and Info.plist configuration. Core NFC apps require the `com.apple.developer.nfc.readersession.formats` entitlement declaring which tag types the app will read, plus `NFCReaderUsageDescription` in Info.plist with a user-facing usage rationale. For apps that need to bind to specific NDEF record types (AAR, URL prefix matching), additional Info.plist entries define the URI prefixes. Apple reviews NFC apps under the usual App Store guidelines; legitimate B2B and consumer-brand use cases are approved routinely.
• NDEF writing pattern: read the tag's NDEF status (supported, read-only), build an `NFCNDEFMessage` with one or more `NFCNDEFPayload` records, and call `tag.writeNDEF(message) { ... }`. Error handling covers full-memory cases, read-only tags, tag-out-of-range during write, and session invalidation. Production apps should implement retry logic with appropriate user messaging.
• Background NDEF URL detection. iPhone automatically detects NDEF URL tags in the background without any app installed, displaying a system notification that opens the URL in Safari or triggers Universal Links to deep-link into an installed app. Developers building a brand app should register Universal Links for the domains encoded on tags, so tap interactions deep-link into the app seamlessly. A core pattern for consumer NFC programmes at scale.
• APDU-level access for DESFire and ISO 7816 tags — with `NFCISO7816Tag` returned by `NFCTagReaderSession` when the tag is ISO 14443-4, apps can send raw APDUs: a DESFire SelectApplication becomes `NFCISO7816APDU(instructionClass: 0x90, instructionCode: 0x5A, p1Parameter: 0x00, p2Parameter: 0x00, data: Data([0x00, 0x00, 0x00]), expectedResponseLength: -1)`, and `tag.sendCommand(apdu:) { response, sw1, sw2, error in ... }` returns the 0x9100 status and response payload. Apple's SDK does not expose MIFARE Classic Crypto1, so DESFire (AES authentication) is the authenticated-access path on iOS.
• ISO 15693 access for industrial tags. `NFCISO15693Tag` from `NFCTagReaderSession` with polling option `.iso15693` supports ICODE SLIX, ST25DV and similar ISO 15693 chips used in pharmaceutical, library and industrial workflows. Commands include `readMultipleBlocks(requestFlags:blockRange:)`, `writeSingleBlock(requestFlags:blockNumber:dataBlock:)` and `customCommand(requestFlags:customCommandCode:customRequestParameters:)`. Range is generally better than 13.56 MHz ISO 14443 (up to 1m with appropriate readers, though still ~2-4cm on iPhone itself).

Swift code patterns for production iPhone NFC apps

Custom iPhone NFC apps share a small number of reusable code patterns. Session setup, NDEF read/write, APDU send for DESFire and ISO 7816, SUN URL verification for NTAG 424 DNA, and error handling. Teams building iOS NFC apps typically codify these patterns in a shared NFC service layer. This section captures the patterns most relevant to production consumer and enterprise NFC apps.

• Info.plist and entitlement configuration. Every Core NFC app needs `NFCReaderUsageDescription` in Info.plist with a user-facing string (e.g., 'This app reads NFC tags to verify product authenticity'), the `com.apple.developer.nfc.readersession.formats` entitlement listing the tag formats (values: `NDEF`, `TAG` for raw tag access), and for domain-bound NDEF URL records an `com.apple.developer.associated-domains` entry for Universal Links. The entitlement must be enabled in the Apple Developer portal under the app's App ID before Xcode will sign the app.
• NFCNDEFReaderSession for simple reads. The minimum viable NDEF reader is a class conforming to `NFCNDEFReaderSessionDelegate`, implementing `readerSession(_:didDetectNDEFs:)` to receive `[NFCNDEFMessage]`, and starting a session with `let session = NFCNDEFReaderSession(delegate: self, queue: nil, invalidateAfterFirstRead: true); session.alertMessage = "Hold your iPhone near the tag"; session.begin()`. For reads-and-writes a `NFCNDEFReaderSession` with `invalidateAfterFirstRead: false` plus `readerSession(_:didDetect:)` taking `[NFCNDEFTag]` gives access to `tag.writeNDEF(message)`.
• NDEF writing pattern: build a message from records, then connect and write: `let urlRecord = NFCNDEFPayload.wellKnownTypeURIPayload(url: URL(string: "https://proudtek.com/tag/abc123")!)!; let message = NFCNDEFMessage(records: [urlRecord]); session.connect(to: tag) { error in tag.writeNDEF(message) { error in session.alertMessage = error == nil ? "Written" : "Write failed"; session.invalidate() } }`. Handle `.tagConnectionLost`, `.ndefReaderSessionErrorTagNotWritable`, `.ndefReaderSessionErrorTagSizeTooSmall` in your error switch.
• NFCTagReaderSession for ISO 7816 tag access. For DESFire, NTAG 424 DNA, or any ISO 14443-4 tag, use `NFCTagReaderSession(pollingOption: [.iso14443, .iso15693], delegate: self)` and in `tagReaderSession(_:didDetect:)` switch on `.iso7816(let tag)`, `.miFare(let tag)`, `.iso15693(let tag)`, `.feliCa(let tag)`. Always `session.connect(to: genericTag)` before sending commands. Connection failures should trigger a user-facing retry, not silent invalidation.
• NTAG 424 DNA SUN URL verification. The tag URL contains CMAC and UID parameters (e.g., `?picc_data=XXXX&cmac=YYYY`). Verification flow: capture the URL from `NFCNDEFPayload.wellKnownTypeURIPayload`, extract `picc_data` and `cmac`, post to your backend which holds the AES-128 application key, decrypt picc_data to recover UID+counter+random, recompute CMAC, compare. Only the backend sees the key; the iPhone app is a thin transport. Reference: NXP AN12196 SUN message verification.
• Background NDEF URL deep-linking. To make iPhone background tag taps open your app instead of Safari, register a Universal Link for the tag URL's domain: Apple App Site Association JSON at `https://yourdomain.com/.well-known/apple-app-site-association`, your app's `com.apple.developer.associated-domains` includes `applinks:yourdomain.com`, and `SceneDelegate.scene(_:continue:)` handles the incoming `NSUserActivity` with `activity.webpageURL`. Users who don't have the app installed still get the Safari fallback. The URL is usable either way.
• Error handling patterns: Core NFC errors come as `NFCReaderError` with codes like `.readerSessionInvalidationErrorUserCanceled`, `.readerSessionInvalidationErrorSessionTimeout`, `.readerSessionInvalidationErrorFirstNDEFTagRead`, `.readerTransceiveErrorTagConnectionLost`. Production apps should distinguish between user-cancel (no error to the user) and actual failure (show retry). A common retry pattern: on `.tagConnectionLost` during write, attempt a single reconnect+rewrite before surfacing failure. Always set a meaningful `session.alertMessage` before `session.invalidate(errorMessage:)` so the system sheet explains what happened.
• Testing and debugging iOS NFC apps. Test with XS/11/13/15 generation iPhones to verify antenna location variations; use NXP TagInfo (free App Store) to verify what's actually on the tag after writes; use an ACR1252U USB reader with macOS CCID tools (`pcsc_scan`, `scriptor`) to triple-verify tag content; log APDU traffic to a local file during development (the session provides `.description` on APDU responses) and strip the logging for production. Simulator does not emulate NFC, so all testing is on-device.

Apple Wallet, App Clips and NFC-triggered native experiences

Beyond generic NDEF records and custom app development, Apple provides NFC-adjacent native features that many consumer programmes leverage. Apple Wallet passes with NFC interaction, App Clip NFC invocations, and NFC-enabled shortcuts for Apple Home and CarPlay. This section covers the native-experience layer that sits on top of Core NFC.

• Apple Wallet passes with NFC. Passes (event tickets, loyalty cards, membership cards) can be distributed with embedded NFC payloads that present to compatible readers (terminals, gym entries, stadium gates). Passes are delivered via the PassKit framework and, when the iPhone is tapped to a reader, the pass presents its encrypted payload. This is the mechanism for Apple Wallet-based tickets, transit passes and loyalty cards at partnering retailers.
• Core NFC CardSession (iOS 17.4 EEA, iOS 18.1 expanding globally). For developers building HCE-based access, transit, loyalty or identity experiences, iOS 17.4 added `CardSession`, `NFCPresentmentIntentAssertion` and the `NFCWindowSceneDelegate` protocol so third-party apps can emulate ISO 7816 contactless cards directly. Initial release was scoped to banking / wallet apps operating in the European Economic Area, requiring Apple's HCE entitlement; iOS 18 / 18.1 expanded the surface to additional regions and use cases including non-payment access control. Apps should call `CardSession.isEligible` before invoking the presentment sheet so the experience degrades cleanly on non-eligible devices, regions or OS versions.
• App Clips with NFC. iOS 14+ supports App Clip invocation from NFC tags, where tapping a tag launches a lightweight portion of an app without requiring the full app to be installed. Useful for parking apps (tap a meter, launch the payment flow), rental (tap a bike, launch the unlock flow), or restaurant menus (tap a table, launch the ordering experience). App Clips are up to 10 MB and provide a fast path from physical tap to interactive experience.
• NFC for iOS Home / CarPlay automations. Apple Home supports NFC-triggered scenes (via Shortcuts) that activate HomeKit devices when a tag is tapped; CarPlay supports NFC-driven app launches when an iPhone is paired to a vehicle. These patterns are end-user productivity features, typically personal rather than commercial programmes.
• Apple Business Essentials and MDM-enabled NFC. Enterprise-managed iPhone fleets can leverage MDM profiles to pre-configure NFC-triggered workflows, App Clip registrations and Universal Links behavior. Useful for field-service teams, retail associate devices and hospitality deployments where consistent NFC behavior across a managed fleet is important.
• Payment-terminal NFC interaction. iPhone with Apple Pay can interact with any EMV contactless terminal; this is a system-level flow separate from Core NFC, but sometimes relevant for programmes that combine payment with loyalty or membership tags. The integration requires payment network participation (Visa, Mastercard, Amex) and is not a generic NFC tag programming capability.
• Planning for Android alongside iPhone. Virtually all consumer NFC programmes need to work on both iPhone and Android. Since Android has richer NFC APIs and fewer platform restrictions, programmes typically target the iPhone-restricted subset (NDEF URL, basic Wi-Fi records, Bluetooth pairing records) as the common denominator, with Shortcuts or custom apps providing iPhone-enhanced experiences for users who want them. A companion Android-programming guide covers the Android side of this cross-platform design.

Proud Tek iPhone-tested NFC products and engagement for NFC programming projects

All the frameworks, entitlements and version gates in this guide eventually meet a much simpler test: a real thumb pressing a real phone against a real tag and expecting it to just work. Choosing the right NFC product is a material determinant of iPhone programming success. Proud Tek supplies a range of NFC tags, stickers, cards and fobs tested on iPhone generations from iPhone 7 through iPhone 16 series, with chip-family documentation, form-factor guidance and iOS-specific testing notes provided as part of the sample and pilot process.

• NTAG 213 stickers — most cost-effective NFC chip for URL and simple-text programmes, with 144 bytes of user memory. Ideal for Google Review cards, business cards, restaurant menus, smart posters, event wristbands and promotional campaigns. Fully iPhone-compatible including background NDEF URL detection on iPhone 7+.
• NTAG 215 stickers — 504 bytes of user memory, roughly 4x NTAG 213 capacity. Good fit for vCards with full contact detail, multi-record tags (URL + text + Wi-Fi), or longer URL strings. Also used for Amiibo-compatible NFC programmes (though iPhone support for Amiibo depends on the specific game app).
• NTAG 216 stickers — 888 bytes, the largest memory in the NTAG 21x family. Use for complex vCards, multi-language text records, or extended smart-poster content. iPhone programming works identically to NTAG 213/215.
• NTAG 424 DNA tags. Advanced chip with per-scan SUN-message cryptographic authentication and dynamic URL features (each tap produces a unique signature). Used for luxury-authentication (handbags, wine, cosmetics), anti-counterfeit programmes and high-value-product digital-passport use cases. iPhone reads DNA tags natively with Core NFC; programming DNA features requires NXP TagWriter or a custom app with NFCTagReaderSession.
• NFC cards (CR80 PVC). Full-color printed PVC cards with NFC chips. Used for business cards, membership cards, access-control credentials, loyalty programmes. iPhone reads and writes identically to stickers. Commonly branded with customer logos and per-card URL serialization.
• NFC fobs and wristbands. Keychain fobs (plastic or silicone), silicone wristbands (events, cashless payments), leather straps (luxury accessories). Form-factor selection depends on the use case; iPhone compatibility is consistent across form factors because the underlying chip is the same. Proud Tek provides iOS-tested sample kits for use-case evaluation.
• Engagement model: Proud Tek's sample programme starts with free iPhone-tested sample kits for evaluation (100-500 tags). Pilot programmes scale to 1k-10k tags per SKU, with pre-encoding services available when the URL or NDEF content is known up-front. Production orders scale to 100k-1M+ tags per run for large consumer programmes, with full QA workflow including iPhone-specific read-verification on a sampled basis.

FAQ