Integration Guide

const LICENSE_KEY = 'LIC-A3F9-K2M7-P8X1-Q4R6';
 
async function verifyLicense() {
  const domain = window.location.hostname;
 
  try {
    const response = await fetch(
      `https://verify.web3.market/verify?license_key=${LICENSE_KEY}&domain=${domain}`
    );
    const data = await response.json();
 
    if (!data.valid) {
      console.error('License verification failed:', data.reason);
      // Handle invalid license — show notice, disable features, etc.
      showLicenseNotice(data.reason);
      return false;
    }
 
    // License is valid — proceed normally
    return true;
  } catch (error) {
    console.error('License verification request failed:', error);
    // Network error — handle gracefully (see best practices below)
    return true; // Fail open to avoid blocking users during outages
  }
}
 
// Run on page load
verifyLicense();

const express = require('express');
const app = express();
 
const LICENSE_KEY = process.env.LICENSE_KEY; // Store in environment variable
const DEPLOYMENT_DOMAIN = process.env.DEPLOYMENT_DOMAIN; // e.g., 'mydapp.com'
 
let licenseValid = null;
let lastCheck = 0;
const CACHE_DURATION = 60 * 60 * 1000; // 1 hour
 
async function verifyLicense() {
  const now = Date.now();
 
  // Return cached result if still fresh
  if (licenseValid !== null && now - lastCheck < CACHE_DURATION) {
    return licenseValid;
  }
 
  try {
    const response = await fetch(
      `https://verify.web3.market/verify?license_key=${LICENSE_KEY}&domain=${DEPLOYMENT_DOMAIN}`
    );
    const data = await response.json();
 
    licenseValid = data.valid;
    lastCheck = now;
 
    if (!data.valid) {
      console.error(`License invalid: ${data.reason}`);
    }
 
    return data.valid;
  } catch (error) {
    console.error('License verification request failed:', error);
    // If we have a cached result, use it; otherwise fail open
    return licenseValid !== null ? licenseValid : true;
  }
}
 
// Middleware to check license on every request
app.use(async (req, res, next) => {
  const isValid = await verifyLicense();
 
  if (!isValid) {
    return res.status(403).json({
      error: 'This deployment is not licensed. Please activate your license at web3.market.'
    });
  }
 
  next();
});
 
app.listen(3000, () => {
  console.log('Server running on port 3000');
  // Verify on startup
  verifyLicense().then((valid) => {
    console.log(`License status: ${valid ? 'valid' : 'invalid'}`);
  });
});

import os
import time
import requests
from flask import Flask, jsonify
 
app = Flask(__name__)
 
LICENSE_KEY = os.environ.get('LICENSE_KEY')
DEPLOYMENT_DOMAIN = os.environ.get('DEPLOYMENT_DOMAIN')
CACHE_DURATION = 3600  # 1 hour in seconds
 
license_cache = {
    'valid': None,
    'last_check': 0
}
 
def verify_license():
    now = time.time()
 
    # Return cached result if still fresh
    if (license_cache['valid'] is not None and
            now - license_cache['last_check'] < CACHE_DURATION):
        return license_cache['valid']
 
    try:
        response = requests.get(
            'https://verify.web3.market/verify',
            params={
                'license_key': LICENSE_KEY,
                'domain': DEPLOYMENT_DOMAIN
            },
            timeout=10
        )
        data = response.json()
 
        license_cache['valid'] = data.get('valid', False)
        license_cache['last_check'] = now
 
        if not data.get('valid'):
            print(f"License invalid: {data.get('reason')}")
 
        return data.get('valid', False)
 
    except requests.RequestException as e:
        print(f"License verification request failed: {e}")
        # Use cached result if available; otherwise fail open
        if license_cache['valid'] is not None:
            return license_cache['valid']
        return True
 
@app.before_request
def check_license():
    if not verify_license():
        return jsonify({
            'error': 'This deployment is not licensed.'
        }), 403
 
if __name__ == '__main__':
    # Verify on startup
    is_valid = verify_license()
    print(f"License status: {'valid' if is_valid else 'invalid'}")
    app.run(port=3000)