Gå til indholdet

Flash-opkald

Flash Call er en telefonbekræftelsesmetode, der bruger et ubesvaret opkald i stedet for SMS til at bekræfte telefonnumre. Det er hurtigere, mere sikkert og omkostningseffektivt.

Oversigt

Flash-opkaldsbekræftelse fungerer ved:

  1. Bruger anmoder om verifikation
  2. Systemet starter et opkald til brugerens telefon
  3. Opkaldet afsluttes automatisk efter 1-2 ring
  4. Brugerens app fanger opkalds-id'et
  5. Opkalds-id er verificeret i forhold til forventet mønster
  6. Brugeren er godkendt

Fordele

Omkostningseffektiv

  • Op til 10 gange billigere end SMS
  • Ingen gebyrer for levering af beskeder
  • Reducerede omkostninger til højvolumenverifikation

Hurtigere

  • Øjeblikkelig bekræftelse (1-3 sekunder)
  • Ingen ventetid på SMS-levering
  • Bedre brugeroplevelse

Mere sikkert

  • Sværere at opsnappe end SMS
  • Ingen OTP synlig i meddelelser
  • Modstandsdygtig over for SIM-bytteangreb

Global rækkevidde

  • Virker i lande med SMS-begrænsninger
  • Ingen problemer med SMS-filtrering
  • Universal telefonkompatibilitet

Basic Flash Call

Anmodning

{
  "from": "YourApp",
  "to": "+380XXXXXXXXX",
  "type": "flashcall",
  "messageData": {
    "callerId": "+380123456789"
  }
}

Parametre

Parameter Skriv Påkrævet Beskrivelse
fra streng Ja Din afsender-id
til streng Ja Modtagerens telefonnummer (E.164)
type streng Ja Indstil til "flashcall"
callerId streng Ja Telefonnummer, der vil ringe til bruger
ttl heltal Nej Tid til at leve i sekunder (standard: 60)

Sådan fungerer det

1. Bruger indtaster telefonnummer

Brugeren angiver sit telefonnummer i din app:

Phone: +380XXXXXXXXX

2. Anmod om Flash Call

Din server anmoder om bekræftelse af flashopkald:

curl -X POST https://restapi.smsbat.com/bat/messagelist \
  -H "X-Authorization-Key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [{
      "from": "YourApp",
      "to": "+380XXXXXXXXX",
      "type": "flashcall",
      "messageData": {
        "callerId": "+380123456789"
      },
      "ttl": 60
    }]
  }'

3. API-svar

API returnerer det forventede opkalds-id-mønster:

{
  "messagelistId": 123456,
  "messages": [
    {
      "messageId": "abc123def456",
      "status": "accepted",
      "callerId": "+380123456789",
      "pattern": "***456789",
      "to": "+380XXXXXXXXX"
    }
  ]
}

4. Start opkald

Systemet starter et opkald til brugerens telefon og afslutter efter 1-2 ring.

5. Hent opkalds-id

Brugerens app fanger det indgående opkalds opkalds-id:

// Android example
val cursor = contentResolver.query(
    CallLog.Calls.CONTENT_URI,
    arrayOf(CallLog.Calls.NUMBER),
    null, null,
    CallLog.Calls.DATE + " DESC"
)

6. Bekræft mønster

Sammenlign optaget opkalds-id med forventet mønster:

// JavaScript example
function verifyFlashCall(callerId, pattern) {
  // Remove non-digits
  const callerDigits = callerId.replace(/\D/g, '');
  const patternDigits = pattern.replace(/\*/g, '.');

  // Check if matches pattern
  const regex = new RegExp(patternDigits);
  return regex.test(callerDigits);
}

Implementeringseksempler

Android

class FlashCallVerification {
    fun requestFlashCall(phoneNumber: String) {
        // 1. Request flash call from API
        val response = api.requestFlashCall(phoneNumber)
        val pattern = response.pattern

        // 2. Wait for incoming call
        val callReceiver = object : BroadcastReceiver() {
            override fun onReceive(context: Context, intent: Intent) {
                if (intent.action == TelephonyManager.ACTION_PHONE_STATE_CHANGED) {
                    val state = intent.getStringExtra(TelephonyManager.EXTRA_STATE)

                    if (state == TelephonyManager.EXTRA_STATE_RINGING) {
                        val callerId = intent.getStringExtra(
                            TelephonyManager.EXTRA_INCOMING_NUMBER
                        )

                        // 3. Verify caller ID against pattern
                        if (verifyPattern(callerId, pattern)) {
                            onVerificationSuccess()
                        }
                    }
                }
            }
        }

        // Register receiver
        context.registerReceiver(
            callReceiver,
            IntentFilter(TelephonyManager.ACTION_PHONE_STATE_CHANGED)
        )
    }

    private fun verifyPattern(callerId: String?, pattern: String): Boolean {
        if (callerId == null) return false

        val regex = pattern.replace("*", "\\d").toRegex()
        return regex.matches(callerId)
    }
}

iOS

class FlashCallVerification {
    func requestFlashCall(phoneNumber: String) {
        // 1. Request flash call from API
        api.requestFlashCall(phoneNumber) { response in
            let pattern = response.pattern

            // 2. Use CallKit to detect incoming call
            let provider = CXProvider(configuration: providerConfiguration)
            provider.setDelegate(self, queue: nil)

            // Store pattern for verification
            self.expectedPattern = pattern
        }
    }

    // CallKit delegate
    func provider(_ provider: CXProvider, perform action: CXAnswerCallAction) {
        // Capture caller ID
        let callerId = action.callUUID.uuidString

        // Verify against pattern
        if verifyPattern(callerId: callerId, pattern: expectedPattern) {
            onVerificationSuccess()
        }

        action.fulfill()
    }

    private func verifyPattern(callerId: String, pattern: String) -> Bool {
        let regex = try! NSRegularExpression(
            pattern: pattern.replacingOccurrences(of: "*", with: "\\d")
        )
        let range = NSRange(location: 0, length: callerId.count)
        return regex.firstMatch(in: callerId, range: range) != nil
    }
}

Web (server-side)

// Node.js example
const express = require('express');
const app = express();

app.post('/request-verification', async (req, res) => {
  const { phoneNumber } = req.body;

  // 1. Request flash call
  const response = await fetch('https://restapi.smsbat.com/bat/messagelist', {
    method: 'POST',
    headers: {
      'X-Authorization-Key': process.env.SMSBAT_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      messages: [{
        from: 'YourApp',
        to: phoneNumber,
        type: 'flashcall',
        messageData: {
          callerId: process.env.FLASH_CALL_NUMBER
        },
        ttl: 60
      }]
    })
  });

  const data = await response.json();
  const { messageId, pattern } = data.messages[0];

  // 2. Store pattern for verification
  await redis.setex(`flashcall:${messageId}`, 60, pattern);

  // 3. Return pattern to client
  res.json({ messageId, pattern });
});

app.post('/verify-flashcall', async (req, res) => {
  const { messageId, callerId } = req.body;

  // 1. Get expected pattern
  const pattern = await redis.get(`flashcall:${messageId}`);

  if (!pattern) {
    return res.status(400).json({ error: 'Verification expired' });
  }

  // 2. Verify caller ID
  const regex = new RegExp(pattern.replace(/\*/g, '\\d'));
  const isValid = regex.test(callerId);

  if (isValid) {
    // Mark phone as verified
    await markPhoneVerified(callerId);
    res.json({ verified: true });
  } else {
    res.status(400).json({ error: 'Invalid caller ID' });
  }
});

Svarformat

Successvar

{
  "messagelistId": 123456,
  "messages": [
    {
      "messageId": "abc123def456",
      "status": "accepted",
      "callerId": "+380123456789",
      "pattern": "***456789",
      "to": "+380XXXXXXXXX",
      "ttl": 60
    }
  ]
}

Svarfelter

Felt Skriv Beskrivelse
messageId streng Unikt verifikations-id
status streng Status: accepteret, afvist
callerId streng Fuldt opkalds-id-nummer
mønster streng Mønster til at matche (cifre + stjerner)
til streng Modtagerens telefonnummer
ttl heltal Gyldighedsperiode i sekunder

Mønstertilpasning

API'en returnerer et mønster med stjerner, der maskerer nogle cifre:

Full number: +380123456789
Pattern:     ***456789

Din app skal:

  1. Registrer indgående opkalds-id
  2. Udtræk cifre fra opkalds-ID
  3. Match med mønster (stjerner = ethvert ciffer)
  4. Bekræft match inden for TTL-perioden

Tilbage til SMS

Hvis Flash Call mislykkes, skal du automatisk vende tilbage til SMS:

{
  "from": "YourApp",
  "to": "+380XXXXXXXXX",
  "type": "flashcall",
  "messageData": {
    "callerId": "+380123456789"
  },
  "fallback": {
    "type": "sms",
    "text": "Your verification code is: 123456"
  },
  "ttl": 60
}

Use Cases

Kontoregistrering

Bekræft telefonnumre under tilmelding uden SMS-omkostninger.

Loginbekræftelse

To-faktor-godkendelse ved hjælp af flash-opkald.

Opdatering af telefonnummer

Bekræft nyt telefonnummer, når brugeren opdaterer profilen.

Transaktionsbekræftelse

Bekræft transaktioner med høj værdi med flashopkald.

Bedste praksis

TTL

  • ✅ Indstil TTL til 60-90 sekunder
  • ✅ Tillad brugeren at prøve igen efter udløb
  • ❌ Brug ikke TTL længere end 120 sekunder

Brugeroplevelse

  • Vis beskeden "Venter på opkald...".
  • Vis nedtællingstimer (60 sekunder)
  • Giv mulighed for "Brug SMS i stedet"
  • Opdag og bekræft automatisk opkalds-id

Fejlhåndtering

  • Håndter manglende telefontilladelser
  • Timeout efter TTL udløber
  • Giv mulighed for SMS-faldback
  • Vis klare fejlmeddelelser

Tilladelser

Anmod om telefontilladelser før flashopkald:

Android: 

<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<uses-permission android:name="android.permission.READ_CALL_LOG" />

iOS: 

<key>NSPhoneCallUsageDescription</key>
<string>We need phone access to verify your number</string>

Test

  • Test på forskellige enheder
  • Test med forskellige transportører
  • Test scenarier for nægtelse af tilladelser
  • Test netværkstimeoutscenarier

Begrænsninger

Platformsupport

  • Virker på alle mobile enheder
  • Kræver mulighed for telefonopkald
  • Kræver READ_PHONE_STATE-tilladelse
  • Virker muligvis ikke på tablets uden telefon

Netværk

  • Kræver aktiv telefonforbindelse
  • Kan fejle under dårlige netværksforhold
  • Transportørrestriktioner kan gælde
  • Internationale priser kan variere

Privatliv

  • Brugere kan blokere ukendte numre
  • Nogle enheder har opkaldsblokering
  • Kræver eksplicitte tilladelser
  • Overvej bekymringer om brugernes privatliv

Fejlfinding

Opkald ikke modtaget

  • Tjek, at telefonen har signal
  • Bekræft talformat (E.164)
  • Tjek operatørens begrænsninger
  • Prøv SMS fallback

Mønster matcher ikke

  • Sørg for at fange korrekt opkalds-id
  • Fjern ikke-cifrede tegn
  • Tjek mønsterformat
  • Bekræft inden for TTL-perioden

Tilladelse nægtet

  • Anmod om tilladelser korrekt
  • Forklar, hvorfor tilladelser er nødvendige
  • Give alternativ (SMS)
  • Håndter med ynde

Næste trin