"zelid": "your-wallet-address",
  "signature": "signed-message-signature", 
  "loginPhrase": "temporary-login-phrase"
} ```
**Note**: Signature values may need to be URL-encoded depending on your HTTP client.

### 5. Start Making API Calls
Test your setup with public endpoints first, then proceed to authenticated endpoints once your credentials are properly configured.

## Support & Community
- **Documentation**: [docs.runonflux.com](https://docs.runonflux.com) - **Discord Community**: [discord.io/runonflux](https://discord.io/runonflux)  - **GitHub**: [github.com/RunOnFlux](https://github.com/RunOnFlux) - **Twitter/X**: [@RunOnFlux](https://x.com/runonflux) - **Website**: [runonflux.com](https://runonflux.com)

**🚀 Ready to build on the decentralized web? Let's get started!**

## Important Notes
- Login phrases expire after 15 minutes - Session tokens are valid for up to 14 days - Always use HTTPS in production environments - Signature values may need URL encoding depending on your HTTP client

## Authentication Workflows

### 🔐 Complete Authentication Flow
**Step 1: Get Login Phrase** ```bash curl -X GET "https://api.runonflux.io/id/loginphrase" ```
**Step 2: Sign the Login Phrase** - **SSP Wallet**: Use browser extension + mobile app to sign the message - **ZelCore**: Use the wallet's message signing feature   - **MetaMask**: Use `personal_sign` method - **Hardware Wallet**: Sign via hardware device integration
**Step 3: Verify Login**  ```bash curl -X POST "https://api.runonflux.io/id/verifylogin" \
  -H "Content-Type: application/json" \
  -d '{
    "zelid": "your-wallet-address",
    "loginPhrase": "phrase-from-step-1", 
    "signature": "your-signature-from-step-2"
  }'

### 📱 SSP Wallet Integration Guide
**Browser Extension Setup:** 1. Install SSP Wallet Chrome Extension 2. Install SSP Key mobile app (iOS/Android) 3. Pair devices using QR code 4. Fund wallet with small amount for testing
**Signing Messages with SSP:** ```javascript // Connect to SSP Wallet if (window.ssp) {
  const accounts = await window.ssp.request({
    method: 'wallet_requestPermissions',
    params: [{ wallet_accounts: {} }]
  });
  
  // Sign login phrase
  const signature = await window.ssp.request({
    method: 'personal_sign',
    params: [loginPhrase, accounts[0]]
  });
} ```

### 🦊 MetaMask Integration Guide
**Connect and Sign:** ```javascript // Connect MetaMask const accounts = await ethereum.request({
  method: 'eth_requestAccounts'
});
// Sign login phrase const signature = await ethereum.request({
  method: 'personal_sign',
  params: [loginPhrase, accounts[0]]
});
// Use Ethereum address as zelid const zelid = accounts[0]; ```

### 🔑 ZelCore Wallet Integration
**Deep Link Integration:** ```javascript // Generate ZelCore deep link for signing const zelcoreUrl = `zel:?action=sign&message=${encodeURIComponent(loginPhrase)}&icon=https://yourapp.com/icon.png&callback=${encodeURIComponent('https://yourapp.com/auth/callback')}`;
// Open ZelCore for signing window.location.href = zelcoreUrl; ```
**WebSocket Integration:** ```javascript // Listen for ZelCore signature via WebSocket const ws = new WebSocket(`wss://api.runonflux.io/ws/id/${loginPhrase}`);
ws.onmessage = (event) => {
  const authData = JSON.parse(event.data);
  if (authData.status === 'success') {
    // Authentication successful
    console.log('Signed in with ZelID:', authData.data.zelid);
  }
}; ```

### 🔗 WalletConnect v2 Integration
**Setup WalletConnect:** ```javascript import { SignClient } from '@walletconnect/sign-client';
const signClient = await SignClient.init({
  projectId: 'your-walletconnect-project-id',
  metadata: {
    name: 'Your Flux App',
    description: 'Flux Network Integration',
    url: 'https://yourapp.com',
    icons: ['https://yourapp.com/logo.png']
  }
});
// Connect to wallet const { uri, approval } = await signClient.connect({
  requiredNamespaces: {
    eip155: {
      methods: ['personal_sign'],
      chains: ['eip155:1'],
      events: ['chainChanged', 'accountsChanged']
    }
  }
});
// Sign message when connected const signature = await signClient.request({
  topic: session.topic,
  chainId: 'eip155:1',
  request: {
    method: 'personal_sign',
    params: [loginPhrase, address]
  }
}); ```

### 📧 Traditional Email Authentication
**Firebase Integration:** ```javascript import { getAuth, signInWithEmailAndPassword } from 'firebase/auth';
// Email/password login const auth = getAuth(); const userCredential = await signInWithEmailAndPassword(auth, email, password);
// Get ID token for API authentication const idToken = await userCredential.user.getIdToken();
// Use token in API calls fetch('https://api.runonflux.io/protected-endpoint', {
  headers: {
    'Authorization': `Bearer ${idToken}`,
    'Content-Type': 'application/json'
  }
}); ```

### ⚠️ Common Integration Issues
**Login Phrase Expiration:** ```javascript // Always check phrase timestamp const phraseTimestamp = parseInt(loginPhrase.substring(0, 13)); const now = Date.now(); const age = now - phraseTimestamp;
if (age > 15 * 60 * 1000) { // 15 minutes
  throw new Error('Login phrase expired, get a new one');
} ```
**Signature URL Encoding:** ```javascript // Always URL encode signatures for headers const encodedSignature = encodeURIComponent(signature); const authHeader = `zelid=${zelid}&signature=${encodedSignature}&loginPhrase=${loginPhrase}`; ```
**Error Handling:** ```javascript try {
  const response = await fetch('/api/authenticated-endpoint', {
    headers: { 'zelidauth': authHeader }
  });
  
  if (response.status === 401) {
    // Re-authenticate user
    redirectToLogin();
  }
} catch (error) {
  console.error('API call failed:', error);
} ```

## API Version Information
**Current Version**: 6.6.1
**Version Notes**: - All endpoints documented in this specification are available in version 6.6.1 - This documentation reflects the current stable API implementation - For the latest changes and updates, refer to the [Flux GitHub repository](https://github.com/runonflux/flux)