Verifly API Documentation

// server.js
const express = require('express');
const axios = require('axios');
const crypto = require('crypto');

const app = express();
app.use(express.json());

const API_KEY = 'vf_your_api_key';
const SECRET_KEY = 'your_secret_key';

// Create signature
function createSignature(payload) {
  const timestamp = Date.now().toString();
  const data = timestamp + JSON.stringify(payload);
  const signature = crypto.createHmac('sha256', SECRET_KEY).update(data).digest('hex');
  return { signature, timestamp };
}

// Create session
app.post('/api/verify', async (req, res) => {
  const payload = {
    phone: req.body.phone,
    methods: ['sms', 'whatsapp'],
    lang: 'tr',
    webhookUrl: 'https://yoursite.com/webhook'
  };
  
  const { signature, timestamp } = createSignature(payload);
  
  const response = await axios.post('https://www.verifly.net/api/verify/create', payload, {
    headers: {
      'X-API-Key': API_KEY,
      'X-Signature': signature,
      'X-Timestamp': timestamp
    }
  });
  
  res.json(response.data);
});

// Webhook handler
app.post('/webhook', (req, res) => {
  const signature = req.headers['x-verifly-signature'];
  const timestamp = req.headers['x-verifly-timestamp'];
  
  // Verify signature
  const data = timestamp + JSON.stringify(req.body);
  const expected = crypto.createHmac('sha256', SECRET_KEY).update(data).digest('hex');
  
  if (signature !== expected) {
    return res.status(401).json({ error: 'Invalid signature' });
  }
  
  // Process event
  if (req.body.event === 'verification.success') {
    console.log('✅ Verified:', req.body.sessionId);
  }
  
  res.json({ received: true });
});

app.listen(3000);

<?php
// app/Services/VeriflyService.php
namespace App\Services;

use Illuminate\Support\Facades\Http;

class VeriflyService {
    private $apiKey;
    private $secretKey;
    
    public function __construct() {
        $this->apiKey = config('services.verifly.api_key');
        $this->secretKey = config('services.verifly.secret_key');
    }
    
    public function createSession($phone = null) {
        $payload = [
            'phone' => $phone,
            'methods' => ['sms', 'whatsapp'],
            'lang' => 'tr',
            'webhookUrl' => route('webhook.verifly')
        ];
        
        $timestamp = (string)(time() * 1000);
        $data = $timestamp . json_encode($payload);
        $signature = hash_hmac('sha256', $data, $this->secretKey);
        
        return Http::withHeaders([
            'X-API-Key' => $this->apiKey,
            'X-Signature' => $signature,
            'X-Timestamp' => $timestamp
        ])->post('https://www.verifly.net/api/verify/create', $payload)->json();
    }
    
    public function verifyWebhook($signature, $timestamp, $payload) {
        $data = $timestamp . json_encode($payload);
        $expected = hash_hmac('sha256', $data, $this->secretKey);
        return hash_equals($expected, $signature);
    }
}

// app/Http/Controllers/WebhookController.php
namespace App\Http\Controllers;

use App\Services\VeriflyService;

class WebhookController extends Controller {
    public function handle(Request $request, VeriflyService $verifly) {
        $sig = $request->header('X-Verifly-Signature');
        $ts = $request->header('X-Verifly-Timestamp');
        
        if (!$verifly->verifyWebhook($sig, $ts, $request->all())) {
            return response()->json(['error' => 'Invalid'], 401);
        }
        
        if ($request->event === 'verification.success') {
            // Mark user as verified
        }
        
        return response()->json(['received' => true]);
    }
}
?>

from flask import Flask, request, jsonify
import requests
import hmac
import hashlib
import json
import time

app = Flask(__name__)

API_KEY = 'vf_your_api_key'
SECRET_KEY = 'your_secret_key'

def create_signature(payload):
    timestamp = str(int(time.time() * 1000))
    data = timestamp + json.dumps(payload, separators=(',', ':'))
    signature = hmac.new(
        SECRET_KEY.encode(),
        data.encode(),
        hashlib.sha256
    ).hexdigest()
    return {'signature': signature, 'timestamp': timestamp}

@app.route('/api/verify', methods=['POST'])
def create_session():
    payload = {
        'phone': request.json.get('phone'),
        'methods': ['sms', 'whatsapp'],
        'lang': 'tr',
        'webhookUrl': 'https://yoursite.com/webhook'
    }
    
    auth = create_signature(payload)
    
    response = requests.post(
        'https://www.verifly.net/api/verify/create',
        json=payload,
        headers={
            'X-API-Key': API_KEY,
            'X-Signature': auth['signature'],
            'X-Timestamp': auth['timestamp']
        }
    )
    
    return jsonify(response.json())

@app.route('/webhook', methods=['POST'])
def webhook():
    signature = request.headers.get('X-Verifly-Signature')
    timestamp = request.headers.get('X-Verifly-Timestamp')
    
    data = timestamp + json.dumps(request.json, separators=(',', ':'))
    expected = hmac.new(SECRET_KEY.encode(), data.encode(), hashlib.sha256).hexdigest()
    
    if signature != expected:
        return jsonify({'error': 'Invalid'}), 401
    
    if request.json['event'] == 'verification.success':
        print('✅ Verified:', request.json['sessionId'])
    
    return jsonify({'received': True})

app.run(port=5000)

// VeriflyService.js
import CryptoJS from 'crypto-js';

const API_KEY = 'vf_your_api_key';
const SECRET_KEY = 'your_secret_key';
const BASE_URL = 'https://www.verifly.net/api';

function createSignature(payload) {
  const timestamp = Date.now().toString();
  const data = timestamp + JSON.stringify(payload);
  const signature = CryptoJS.HmacSHA256(data, SECRET_KEY).toString();
  return { signature, timestamp };
}

export async function createVerification(phone) {
  const payload = {
    phone,
    methods: ['sms', 'whatsapp'],
    lang: 'tr',
    webhookUrl: 'https://yourapi.com/webhook'
  };
  
  const { signature, timestamp } = createSignature(payload);
  
  const response = await fetch(`${BASE_URL}/verify/create`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': API_KEY,
      'X-Signature': signature,
      'X-Timestamp': timestamp
    },
    body: JSON.stringify(payload)
  });
  
  return await response.json();
}

// VerificationScreen.js
import React, { useState, useRef } from 'react';
import { View, StyleSheet } from 'react-native';
import { WebView } from 'react-native-webview';
import { createVerification } from './VeriflyService';

export default function VerificationScreen({ userPhone }) {
  const [iframeUrl, setIframeUrl] = useState(null);
  const webViewRef = useRef(null);

  React.useEffect(() => {
    // Create session and get iframe URL
    createVerification(userPhone).then(result => {
      setIframeUrl(result.data.iframeUrl);
    });
  }, [userPhone]);

  const handleWebViewMessage = (event) => {
    const data = JSON.parse(event.nativeEvent.data);
    
    if (data.event === 'verification.success') {
      console.log('✅ Doğrulama başarılı!', data.sessionId);
      // Notify backend or navigate
    }
  };

  if (!iframeUrl) {
    return <View style={styles.loading} />;
  }

  return (
    <View style={styles.container}>
      <WebView
        ref={webViewRef}
        source={{ uri: iframeUrl }}
        style={styles.webview}
        onMessage={handleWebViewMessage}
        javaScriptEnabled={true}
      />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: '#fff',
  },
  webview: {
    flex: 1,
  },
  loading: {
    flex: 1,
    backgroundColor: '#f5f5f5',
  },
});

// VeriflyService.swift
import Foundation
import CryptoKit

class VeriflyService {
    let apiKey = "vf_your_api_key"
    let secretKey = "your_secret_key"
    let baseURL = "https://www.verifly.net/api"
    
    func createSignature(payload: [String: Any]) -> (signature: String, timestamp: String) {
        let timestamp = String(Int(Date().timeIntervalSince1970 * 1000))
        let jsonData = try! JSONSerialization.data(withJSONObject: payload)
        let jsonString = String(data: jsonData, encoding: .utf8)!
        let data = timestamp + jsonString
        
        let key = SymmetricKey(data: Data(secretKey.utf8))
        let signature = HMAC<SHA256>.authenticationCode(for: Data(data.utf8), using: key)
        let signatureHex = signature.map { String(format: "%02x", $0) }.joined()
        
        return (signatureHex, timestamp)
    }
    
    func createVerification(phone: String, completion: @escaping (Result<String, Error>) -> Void) {
        let payload: [String: Any] = [
            "phone": phone,
            "methods": ["sms", "whatsapp"],
            "lang": "tr",
            "webhookUrl": "https://yourapi.com/webhook"
        ]
        
        let (signature, timestamp) = createSignature(payload: payload)
        
        var request = URLRequest(url: URL(string: "\\(baseURL)/verify/create")!)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.setValue(apiKey, forHTTPHeaderField: "X-API-Key")
        request.setValue(signature, forHTTPHeaderField: "X-Signature")
        request.setValue(timestamp, forHTTPHeaderField: "X-Timestamp")
        request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
        
        URLSession.shared.dataTask(with: request) { data, response, error in
            if let error = error {
                completion(.failure(error))
                return
            }
            
            if let data = data,
               let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
               let sessionData = json["data"] as? [String: Any],
               let iframeUrl = sessionData["iframeUrl"] as? String {
                completion(.success(iframeUrl))
            }
        }.resume()
    }
}

// VerificationViewController.swift
import UIKit
import WebKit

class VerificationViewController: UIViewController, WKScriptMessageHandler {
    var webView: WKWebView!
    let veriflyService = VeriflyService()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // WKWebView setup
        let configuration = WKWebViewConfiguration()
        configuration.userContentController.add(self, name: "verifly")
        
        webView = WKWebView(frame: view.bounds, configuration: configuration)
        webView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        view.addSubview(webView)
        
        // Create session and load iframe
        loadVerification()
    }
    
    func loadVerification() {
        veriflyService.createVerification(phone: "05551234567") { result in
            switch result {
            case .success(let iframeUrl):
                DispatchQueue.main.async {
                    if let url = URL(string: iframeUrl) {
                        self.webView.load(URLRequest(url: url))
                    }
                }
            case .failure(let error):
                print("Error:", error)
            }
        }
    }
    
    // WebView message handler
    func userContentController(_ userContentController: WKUserContentController, 
                                didReceive message: WKScriptMessage) {
        if message.name == "verifly",
           let dict = message.body as? [String: Any],
           let event = dict["event"] as? String {
            
            if event == "verification.success" {
                print("✅ Doğrulama başarılı!")
                // Notify backend or navigate
            }
        }
    }
    
    deinit {
        webView?.configuration.userContentController.removeScriptMessageHandler(forName: "verifly")
    }
}

// VeriflyService.kt
import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec

class VeriflyService {
    private val apiKey = "vf_your_api_key"
    private val secretKey = "your_secret_key"
    private val baseURL = "https://www.verifly.net/api"
    private val client = OkHttpClient()
    
    private fun createSignature(payload: JSONObject): Pair<String, String> {
        val timestamp = System.currentTimeMillis().toString()
        val data = timestamp + payload.toString()
        
        val mac = Mac.getInstance("HmacSHA256")
        mac.init(SecretKeySpec(secretKey.toByteArray(), "HmacSHA256"))
        val signature = mac.doFinal(data.toByteArray()).joinToString("") { "%02x".format(it) }
        
        return Pair(signature, timestamp)
    }
    
    fun createVerification(phone: String, callback: (String?) -> Unit) {
        val payload = JSONObject().apply {
            put("phone", phone)
            put("methods", listOf("sms", "whatsapp"))
            put("lang", "tr")
            put("webhookUrl", "https://yourapi.com/webhook")
        }
        
        val (signature, timestamp) = createSignature(payload)
        
        val request = Request.Builder()
            .url("$baseURL/verify/create")
            .post(payload.toString().toRequestBody("application/json".toMediaType()))
            .addHeader("X-API-Key", apiKey)
            .addHeader("X-Signature", signature)
            .addHeader("X-Timestamp", timestamp)
            .build()
        
        client.newCall(request).enqueue(object : Callback {
            override fun onFailure(call: Call, e: IOException) {
                callback(null)
            }
            
            override fun onResponse(call: Call, response: Response) {
                val json = response.body?.string()?.let { JSONObject(it) }
                val iframeUrl = json?.getJSONObject("data")?.getString("iframeUrl")
                callback(iframeUrl)
            }
        })
    }
}

// VerificationActivity.kt
import android.annotation.SuppressLint
import android.os.Bundle
import android.webkit.WebView
import android.webkit.WebViewClient
import android.webkit.JavascriptInterface
import androidx.appcompat.app.AppCompatActivity

class VerificationActivity : AppCompatActivity() {
    private val veriflyService = VeriflyService()
    private lateinit var webView: WebView
    
    @SuppressLint("SetJavaScriptEnabled")
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        webView = WebView(this)
        webView.settings.javaScriptEnabled = true
        webView.settings.domStorageEnabled = true
        webView.webViewClient = WebViewClient()
        webView.addJavascriptInterface(WebAppInterface(), "Android")
        
        setContentView(webView)
        
        // Create session and load iframe
        loadVerification()
    }
    
    private fun loadVerification() {
        veriflyService.createVerification("05551234567") { iframeUrl ->
            runOnUiThread {
                iframeUrl?.let {
                    webView.loadUrl(it)
                }
            }
        }
    }
    
    inner class WebAppInterface {
        @JavascriptInterface
        fun onVerificationSuccess(sessionId: String) {
            runOnUiThread {
                println("✅ Doğrulama başarılı: $sessionId")
                // Notify backend or navigate
            }
        }
    }
}

// main.go
package main

import (
    "bytes"
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "html/template"
    "io/ioutil"
    "net/http"
    "strconv"
    "time"
)

const (
    APIKey    = "vf_your_api_key"
    SecretKey = "your_secret_key"
    BaseURL   = "https://www.verifly.net/api"
)

type VerificationPayload struct {
    Phone      string   `json:"phone"`
    Methods    []string `json:"methods"`
    Lang       string   `json:"lang"`
    WebhookURL string   `json:"webhookUrl,omitempty"`
}

type VerificationResponse struct {
    Success bool                   `json:"success"`
    Data    map[string]interface{} `json:"data"`
}

func createSignature(payload interface{}) (string, string, error) {
    timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
    jsonData, _ := json.Marshal(payload)
    data := timestamp + string(jsonData)
    
    h := hmac.New(sha256.New, []byte(SecretKey))
    h.Write([]byte(data))
    signature := hex.EncodeToString(h.Sum(nil))
    
    return signature, timestamp, nil
}

func createVerification(phone string) (string, error) {
    payload := VerificationPayload{
        Phone:      phone,
        Methods:    []string{"sms", "whatsapp"},
        Lang:       "tr",
        WebhookURL: "https://yoursite.com/webhook",
    }
    
    signature, timestamp, _ := createSignature(payload)
    jsonData, _ := json.Marshal(payload)
    
    req, _ := http.NewRequest("POST", BaseURL+"/verify/create", bytes.NewBuffer(jsonData))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-API-Key", APIKey)
    req.Header.Set("X-Signature", signature)
    req.Header.Set("X-Timestamp", timestamp)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    
    body, _ := ioutil.ReadAll(resp.Body)
    var result VerificationResponse
    json.Unmarshal(body, &result)
    
    // Return iframe URL
    return result.Data["iframeUrl"].(string), nil
}

// Verification page handler
func verifyHandler(w http.ResponseWriter, r *http.Request) {
    phone := r.URL.Query().Get("phone")
    if phone == "" {
        phone = "05551234567" // Default
    }
    
    iframeURL, err := createVerification(phone)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    
    tmpl := `
<!DOCTYPE html>

<html>

<head>

    <title>Phone Verification</title>

    <style>

        body { margin: 0; padding: 20px; font-family: Arial; }

        iframe { width: 100%; height: 600px; border: 1px solid #ddd; border-radius: 8px; }

    </style>

</head>

<body>

    <h1>Verify Your Phone Number</h1>

    <iframe src="{{.IframeURL}}" title="Verifly Verification"></iframe>

</body>

</html>
`
    
    t, _ := template.New("verify").Parse(tmpl)
    t.Execute(w, map[string]string{"IframeURL": iframeURL})
}

// Webhook handler
func webhookHandler(w http.ResponseWriter, r *http.Request) {
    signature := r.Header.Get("X-Verifly-Signature")
    timestamp := r.Header.Get("X-Verifly-Timestamp")
    body, _ := ioutil.ReadAll(r.Body)
    
    // Verify signature
    data := timestamp + string(body)
    h := hmac.New(sha256.New, []byte(SecretKey))
    h.Write([]byte(data))
    expected := hex.EncodeToString(h.Sum(nil))
    
    if signature != expected {
        http.Error(w, "Invalid signature", http.StatusUnauthorized)
        return
    }
    
    var payload map[string]interface{}
    json.Unmarshal(body, &payload)
    
    if payload["event"] == "verification.success" {
        // Mark user as verified in database
        println("✅ Verified:", payload["sessionId"])
    }
    
    json.NewEncoder(w).Encode(map[string]bool{"received": true})
}

func main() {
    http.HandleFunc("/verify", verifyHandler)
    http.HandleFunc("/webhook", webhookHandler)
    
    println("Server running on :8080")
    http.ListenAndServe(":8080", nil)
}