Getting Started with Habilis Domains

Welcome to Habilis Domains! This guide will help you get up and running with domain management and fraud detection in minutes.

Quick Start Checklist

  • [ ] Create your account
  • [ ] Choose a pricing plan
  • [ ] Add your first domain
  • [ ] Configure DNS records
  • [ ] Get your API key
  • [ ] Make your first fraud API call
  • [ ] Explore the dashboard

Estimated Time: 30 minutes

Step 1: Create Your Account

Sign Up

  1. Visit [register page]
  2. Enter your email address
  3. Create a strong password
  4. Verify your email
  5. Complete your profile

Account Security

  • Use a unique, strong password
  • Enable two-factor authentication (recommended)
  • Keep your API keys secure

Step 2: Choose Your Plan

Select the plan that fits your needs:

Starter - $29/month

Best for: Small projects, testing, personal use

  • Up to 10 domains
  • 1,000 fraud API calls/month
  • Email support
  • All core features

Professional - $99/month

Best for: Growing businesses, agencies

  • Up to 100 domains
  • 10,000 fraud API calls/month
  • Priority support
  • Bulk operations (Q1 2026)
  • Analytics dashboard (Q1 2026)

Enterprise - $299/month

Best for: Large organizations, high volume

  • Unlimited domains
  • Unlimited fraud API calls
  • Dedicated support
  • All features + early access
  • Custom integration support

💡 Tip: Start with Starter plan and upgrade as you grow. You can change plans anytime.

Step 3: Add Your First Domain

From the Dashboard

  1. Navigate to Domains

    • Click "Domains" in the sidebar
    • Click "Add Domain" button

  2. Enter Domain Information

    Domain Name: example.com

  3. Update Nameservers

    • Copy the nameservers provided: 
      ns1.habilisdomains.com
ns2.habilisdomains.com
    • Go to your domain registrar
    • Update nameservers to point to Habilis Domains
    • Save changes

  4. Verify Domain

    • Wait 5-15 minutes for propagation
    • Dashboard will show "Active" when verified

Via API

curl -X POST https://api.habilisdomains.com/v1/domains \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "domain": "example.com"
  }'

Step 4: Configure DNS Records

Common DNS Records

A Record (IPv4 Address)

Type: A
Name: @
Value: 192.0.2.1
TTL: 3600

CNAME Record (Alias)

Type: CNAME
Name: www
Value: example.com
TTL: 3600

MX Record (Email)

Type: MX
Name: @
Value: mail.example.com
Priority: 10
TTL: 3600

TXT Record (Verification)

Type: TXT
Name: @
Value: "v=spf1 include:_spf.example.com ~all"
TTL: 3600

Adding Records via Dashboard

  1. Go to Domains > Select your domain
  2. Click "DNS Records"
  3. Click "Add Record"
  4. Select record type
  5. Fill in details
  6. Click "Save"

Adding Records via API

curl -X POST https://api.habilisdomains.com/v1/domains/example.com/records \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "A",
    "name": "@",
    "value": "192.0.2.1",
    "ttl": 3600
  }'

Step 5: Get Your API Key

Generate API Key

  1. Navigate to Settings

    • Click "Settings" in sidebar
    • Click "API Keys" tab

  2. Create New Key

    • Click "Generate API Key"
    • Enter a description (e.g., "Production API")
    • Copy the key immediately
    • Store securely (you won't see it again)

  3. Security Best Practices

    • Never commit keys to version control
    • Use environment variables
    • Rotate keys regularly
    • Use different keys for dev/production

API Key Format

hd_live_1234567890abcdef1234567890abcdef

Step 6: Make Your First Fraud API Call

Assess a Transaction

// Node.js Example
const response = await fetch('https://api.habilisdomains.com/v1/fraud-detection/assess', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    transactionId: 'txn_12345',
    transactionType: 'payment',
    userId: 'user_67890',
    amount: 99.99,
    currency: 'USD',
    paymentMethod: 'credit_card',
    ipAddress: '192.0.2.1',
    userAgent: 'Mozilla/5.0...',
    sessionId: 'sess_abc123'
  })
});

const result = await response.json();
console.log('Risk Score:', result.riskScore);
console.log('Recommendation:', result.recommendation);

Python Example

import requests

response = requests.post(
    'https://api.habilisdomains.com/v1/fraud-detection/assess',
    headers={
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    json={
        'transactionId': 'txn_12345',
        'transactionType': 'payment',
        'userId': 'user_67890',
        'amount': 99.99,
        'currency': 'USD',
        'paymentMethod': 'credit_card',
        'ipAddress': '192.0.2.1',
        'userAgent': 'Mozilla/5.0...',
        'sessionId': 'sess_abc123'
    }
)

result = response.json()
print(f"Risk Score: {result['riskScore']}")
print(f"Recommendation: {result['recommendation']}")

Understanding the Response

{
  "transactionId": "txn_12345",
  "riskScore": 0.23,
  "recommendation": "allow",
  "factors": [
    "Low risk IP address",
    "Normal transaction amount",
    "Verified user"
  ],
  "timestamp": "2025-10-01T10:30:00Z"
}

Risk Score Ranges:

  • 0.0 - 0.3: Low risk → Allow
  • 0.3 - 0.7: Medium risk → Review or require MFA
  • 0.7 - 1.0: High risk → Block or manual review

Step 7: Explore the Dashboard

Key Sections

1. Overview

  • Account summary
  • Recent activity
  • Quick actions

2. Domains

  • List all domains
  • Add/edit/delete domains
  • DNS record management
  • Domain status

3. Fraud Detection

  • API usage statistics
  • Recent fraud assessments
  • Threat tracking
  • Risk score distribution

4. API Keys

  • Manage API keys
  • View usage per key
  • Rotate keys
  • Set permissions

5. Settings

  • Account information
  • Billing details
  • Plan management
  • Security settings

Common Use Cases

Use Case 1: E-commerce Fraud Prevention

// Check transaction before processing payment
async function processPayment(order) {
  // 1. Assess fraud risk
  const fraudCheck = await assessTransaction({
    transactionId: order.id,
    transactionType: 'payment',
    userId: order.userId,
    amount: order.total,
    paymentMethod: order.paymentMethod,
    ipAddress: order.ipAddress
  });
  
  // 2. Take action based on risk
  if (fraudCheck.riskScore > 0.7) {
    // High risk - block transaction
    return { status: 'blocked', reason: 'High fraud risk' };
  } else if (fraudCheck.riskScore > 0.3) {
    // Medium risk - require additional verification
    return { status: 'verify', action: 'require_mfa' };
  } else {
    // Low risk - process payment
    return await processPaymentNormally(order);
  }
}

Use Case 2: Account Registration Protection

// Check new user registration
async function registerUser(userData) {
  // 1. Assess registration risk
  const fraudCheck = await assessTransaction({
    transactionId: `reg_${Date.now()}`,
    transactionType: 'registration',
    userId: userData.email,
    ipAddress: userData.ipAddress,
    userAgent: userData.userAgent
  });
  
  // 2. Handle based on risk
  if (fraudCheck.riskScore > 0.7) {
    // High risk - require email verification + CAPTCHA
    return { status: 'pending', verification: 'email_captcha' };
  } else {
    // Normal registration flow
    return await createUserAccount(userData);
  }
}

Use Case 3: Multi-Domain Management

// Bulk DNS update across domains
async function updateDNSRecords(domains, record) {
  const results = [];
  
  for (const domain of domains) {
    const result = await fetch(
      `https://api.habilisdomains.com/v1/domains/${domain}/records`,
      {
        method: 'POST',
        headers: {
          'Authorization': 'Bearer YOUR_API_KEY',
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(record)
      }
    );
    
    results.push({ domain, success: result.ok });
  }
  
  return results;
}

Next Steps

Learn More

Advanced Features (Coming Q1 2026)

  • [ ] Set up webhook notifications
  • [ ] Use SDK libraries
  • [ ] Configure bulk operations
  • [ ] Access analytics dashboard

Get Help

  • Email: sales@habilisdomains.com
  • Response time: Within 24 hours
  • Coming Q1 2026: AI chatbot, support tickets

Troubleshooting

Domain Not Verifying

Problem: Domain shows "Pending" status

Solutions:

  1. Verify nameservers are correctly set at registrar
  2. Wait 15-30 minutes for DNS propagation
  3. Check for typos in nameserver addresses
  4. Clear your DNS cache
  5. Contact support if issue persists

API Authentication Errors

Problem: Getting 401 Unauthorized errors

Solutions:

  1. Verify API key is correct
  2. Check Authorization header format: Bearer YOUR_API_KEY
  3. Ensure key hasn't been revoked
  4. Generate new key if needed

Rate Limit Exceeded

Problem: Getting 429 Too Many Requests errors

Solutions:

  1. Check your plan's API limits
  2. Implement request caching
  3. Optimize API call frequency
  4. Upgrade to higher plan
  5. Contact sales for Enterprise unlimited access

Best Practices

Security

  • ✅ Use environment variables for API keys
  • ✅ Rotate API keys regularly (every 90 days)
  • ✅ Use different keys for dev/production
  • ✅ Enable two-factor authentication
  • ✅ Monitor API usage for anomalies

Performance

  • ✅ Cache DNS lookups when possible
  • ✅ Batch API requests when feasible
  • ✅ Use appropriate TTL values for DNS
  • ✅ Monitor API response times
  • ✅ Implement retry logic with exponential backoff

Cost Optimization

  • ✅ Start with Starter plan, upgrade as needed
  • ✅ Monitor API usage to avoid overages
  • ✅ Use annual billing for 17% savings
  • ✅ Optimize fraud API calls (cache results)
  • ✅ Review usage monthly

Resources

Documentation

Support

  • Email: sales@habilisdomains.com
  • Response: Within 24 hours

Community

  • Feature requests: sales@habilisdomains.com
  • Bug reports: sales@habilisdomains.com

Welcome to Habilis Domains! 🚀

We're excited to have you on board. If you have any questions, don't hesitate to reach out.

Last Updated: October 1, 2025
Version: Beta 1.0