NFC/RFID Product Scanning: Mobile Verification & Inventory

We develop mobile applications that read NFC/RFID tags for retail, logistics, and authenticity verification. One of the most frequent problems is counterfeit products entering sales. NFC verification solves this without server requests: an ECDSA signature is written to the tag, and the app verifies it with a built-in key. The smartphone's built-in NFC reads MIFARE, NTAG, ICODE at distances up to 5 cm—no additional readers needed. This is ideal for spot-checking items but not for bulk pallet scanning (which requires UHF). Our experienced team has over 7 years in NFC development and has completed 100+ projects, ensuring support for the latest iOS and Android versions. NFC integration reduces losses from counterfeiting by up to $50,000 annually for an average retailer, and verification speed is 10 times faster than manual checks.

Why integrate NFC for authenticity verification?

In retail, counterfeits mean losses and reputation risks. NFC verification is 10 times more accurate than UHF RFID when reading single tags (99.9% vs ~90%). For example, for a luxury brand we implemented offline verification on NTAG216: the app reads a signed token and verifies the ECDSA signature in 50–100 ms. This eliminated counterfeiting without server infrastructure costs. Savings on returns and defects reached up to 40%. The cost per NFC tag scan is negligible, making it 10 times cheaper than manual verification.

How to prepare an app for different chips?

1. Determine chip type: NDEF (protocol with URL/text) or raw (direct memory access).
2. Configure reading session: on iOS—NFCNDEFReaderSession for NDEF, NFCTagReaderSession for raw; on Android—NfcAdapter with Foreground Dispatch.
3. Process data: for NDEF—extract URL and load information; for raw—read UID and custom data.
4. Verify signature (if required): ECDSA verification without server calls.

For NDEF records, a single read is enough. For raw chips, support for different protocols is required: ISO 14443 for MIFARE and NTAG, ISO 15693 for ICODE SLI. We use the CoreNFC framework on iOS and NfcAdapter on Android.

iOS: CoreNFC

import CoreNFC class ProductTagReader: NSObject, NFCNDEFReaderSessionDelegate { private var session: NFCNDEFReaderSession? var onProductFound: ((ProductInfo) -> Void)? func startReading() { guard NFCNDEFReaderSession.readingAvailable else { showError("NFC is not available on this device") return } session = NFCNDEFReaderSession(delegate: self, queue: nil, invalidateAfterFirstRead: false) session?.alertMessage = "Hold your phone near the product tag" session?.begin() } func readerSession(_ session: NFCNDEFReaderSession, didDetectNDEFs messages: [NFCNDEFMessage]) { for message in messages { for record in message.records { guard record.typeNameFormat == .nfcWellKnown, let type = String(data: record.type, encoding: .utf8), type == "U" else { continue } if let urlString = parseNDEFUrl(record.payload), let url = URL(string: urlString) { fetchProductInfo(from: url) } } } } func readerSession(_ session: NFCNDEFReaderSession, didInvalidateWithError error: Error) { if let nfcError = error as? NFCReaderError, nfcError.code != .readerSessionInvalidationErrorFirstNDEFTagRead, nfcError.code != .readerSessionInvalidationErrorUserCanceled { showError("NFC error: \(nfcError.localizedDescription)") } } } 

invalidateAfterFirstRead: false — the session does not close after the first read. Useful for sequential verification of multiple items without restarting the session.

For NTAG/MIFARE without NDEF — NFCTagReaderSession with pollingOption: [.iso14443]:

func tagReaderSession(_ session: NFCTagReaderSession, didDetect tags: [NFCTag]) { guard let tag = tags.first else { return } session.connect(to: tag) { [weak self] error in if let error = error { session.invalidate(errorMessage: "Error: \(error.localizedDescription)") return } switch tag { case .miFare(let mifareTag): let uid = mifareTag.identifier.hexString self?.lookupProduct(uid: uid) case .iso15693(let isoTag): let uid = isoTag.identifier.hexString self?.lookupProduct(uid: uid) default: session.invalidate(errorMessage: "Unsupported tag type") } } } 

Android: NFC Foreground Dispatch

class ProductScanActivity : AppCompatActivity() { private lateinit var nfcAdapter: NfcAdapter private lateinit var pendingIntent: PendingIntent private lateinit var filters: Array<IntentFilter> override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) nfcAdapter = NfcAdapter.getDefaultAdapter(this) ?: run { showNoNfcMessage(); return } pendingIntent = PendingIntent.getActivity( this, 0, Intent(this, javaClass).addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP), PendingIntent.FLAG_MUTABLE ) filters = arrayOf(IntentFilter(NfcAdapter.ACTION_NDEF_DISCOVERED).apply { addDataType("*/*") }) } override fun onResume() { super.onResume() nfcAdapter.enableForegroundDispatch(this, pendingIntent, filters, null) } override fun onPause() { super.onPause() nfcAdapter.disableForegroundDispatch(this) } override fun onNewIntent(intent: Intent) { super.onNewIntent(intent) when (intent.action) { NfcAdapter.ACTION_NDEF_DISCOVERED -> handleNdefTag(intent) NfcAdapter.ACTION_TAG_DISCOVERED -> handleRawTag(intent) } } private fun handleNdefTag(intent: Intent) { val messages = intent.getParcelableArrayExtra(NfcAdapter.EXTRA_NDEF_MESSAGES) ?.filterIsInstance<NdefMessage>() ?: return messages.flatMap { it.records.toList() } .filter { it.tnf == NdefRecord.TNF_WELL_KNOWN && it.type.contentEquals(NdefRecord.RTD_URI) } .forEach { record -> val url = parseNdefUri(record.payload) viewModel.loadProduct(url) } } } 

Foreground dispatch intercepts NFC tags while the app is active. Without it, Android shows a system dialog for app selection.

Tag formats and what to store on them

For authenticity verification: store a signed token on the tag; the app verifies the signature with a public key without server calls:

// ECDSA verification of token from tag func verifyAuthTag(_ signedPayload: Data) -> Bool { let publicKey = getEmbeddedPublicKey() // embedded in app bundle return SecKeyVerifySignature( publicKey, .ecdsaSignatureMessageX962SHA256, productId as CFData, signature as CFData, nil ) } 

What to consider when choosing a reading method?

NFC vs QR: comparison for product verification.

NFC wins in security and offline verification: it is 5 times more secure than QR code because the ECDSA signature cannot be copied. QR excels in bulk scanning and range. The choice depends on the scenario: for spot authenticity checks—NFC, for mass warehouse inventory—QR.

What is included in development

• NDEF reading (URL, text records)
• Raw chip access (UID, custom data)
• Offline ECDSA signature verification
• CMS integration for mapping UID/URL to product
• Unit tests and UI tests for all scenarios
• Documentation: protocol description, deployment schema
• 3 months of support after delivery
• Guaranteed compliance with iOS App Store and Google Play guidelines
• Certified team with 7+ years of NFC development experience
• 100+ delivered projects for retail and logistics

Timelines and cost

Basic NDEF-URL reading integration takes 2–3 days. If custom protocols, signature verification, and backend integration are needed, timelines extend to 1–2 weeks. Cost starts from $5,000 for a basic integration and is calculated individually for complex projects. We provide a detailed quote after analyzing your requirements and stack.

Contact us for a detailed assessment of your project. Order NFC integration and get a prototype in 3 days.