Gaming Sensitivity API

Quick Start

Get started with the Gaming Sensitivity Calculator API in minutes.

Get Your API Key

Contact the administrator to receive your API key via Telegram. You'll get a key in this format:

sk_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Make Your First Request

curl -X POST https://gamingsensitivity.vercel.app/api/generate/freefire \
  -H "Content-Type: application/json" \
  -H "x-api-key: YOUR_API_KEY" \
  -d '{
    "device_name": "iPhone 14 Pro",
    "play_style": "aggressive",
    "experience_level": "advanced",
    "calculator_type": "free"
  }'

Authentication

Include your API key in every request using one of these methods:

Method 1: x-api-key Header (Recommended)

x-api-key: sk_your_api_key_here

Method 2: Authorization Header

Authorization: Bearer sk_your_api_key_here

API Tiers

Rate Limit Headers

Every response includes rate limit information:

X-RateLimit-Limit-Minute: 20
X-RateLimit-Remaining-Minute: 18
X-RateLimit-Limit-Day: 10000
X-RateLimit-Remaining-Day: 9847

Endpoints

Free Fire Sensitivity

Generate optimized sensitivity settings for Free Fire based on device, play style, and experience.

Request Headers

Content-Type: application/json
x-api-key: YOUR_API_KEY

Request Body

Required Fields

{
  "device_name": "iPhone 14 Pro",
  "play_style": "aggressive",
  "experience_level": "advanced",
  "calculator_type": "free"
}

Optional Preferences (VIP Only)

{
  "device_name": "Samsung Galaxy S23 Ultra",
  "play_style": "aggressive",
  "experience_level": "professional",
  "calculator_type": "vip",
  "preferences": {
    "dragSpeed": "fast",
    "weaponType": "ar",
    "fingerConfig": "4-finger",
    "aimAssist": "default",
    "shootingStyle": "drag"
  }
}

Field Values

Success Response (200 OK)

{
  "success": true,
  "data": {
    "general": 176,
    "redDot": 120,
    "scope2x": 102,
    "scope4x": 74,
    "sniperScope": 56,
    "freeLook": 91,
    "fireButtonSize": 48,
    "recommendedDPI": 470,
    "dragAngle": 37.5
  },
  "device_info": {
    "name": "iPhone 14 Pro",
    "type": "apple",
    "performance": "high-end",
    "screenSize": 6.1,
    "refreshRate": 120
  },
  "calculator_type": "vip"
}

Example - JavaScript

const response = await fetch('https://gamingsensitivity.vercel.app/api/generate/freefire', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-api-key': 'sk_your_key_here'
  },
  body: JSON.stringify({
    device_name: 'iPhone 14 Pro',
    play_style: 'aggressive',
    experience_level: 'advanced',
    calculator_type: 'free'
  })
});

const data = await response.json();
console.log(data);

Example - Python

import requests

url = 'https://gamingsensitivity.vercel.app/api/generate/freefire'
headers = {
    'Content-Type': 'application/json',
    'x-api-key': 'sk_your_key_here'
}
payload = {
    'device_name': 'iPhone 14 Pro',
    'play_style': 'aggressive',
    'experience_level': 'advanced',
    'calculator_type': 'free'
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()
print(data)

CODM Sensitivity

Generate optimized sensitivity settings for Call of Duty Mobile.

Request Body

{
  "device_name": "iPhone 14 Pro",
  "finger_count": "4fingers"
}

Field Values

Success Response (200 OK)

{
  "success": true,
  "data": {
    "mp": {
      "cameraFpp": 65,
      "steeringSensitivity": 58,
      "verticalTurningSensitivity": 52,
      "redDot": 45,
      "adsSensitivity": 42,
      "scope4x": 35,
      "sniperScope": 25,
      "firingCameraFpp": 70,
      "firingRedDot": 48,
      "firingScope4x": 38
    },
    "br": {
      "cameraFpp": 68,
      "thirdPersonSensitivity": 62,
      "redDot": 47,
      "scope4x": 37,
      "sniperScope": 27
    }
  },
  "device_info": {
    "name": "iPhone 14 Pro",
    "type": "apple",
    "performance": "flagship",
    "screenSize": 6.1,
    "refreshRate": 120
  }
}

Error Codes

Discord Bot Integration

Create a Discord bot that generates sensitivity settings on command.

Setup

npm install discord.js axios

Bot Code

const { Client, GatewayIntentBits, EmbedBuilder } = require('discord.js');
const axios = require('axios');

const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent
  ]
});

const API_KEY = 'sk_your_key_here';
const API_URL = 'https://gamingsensitivity.vercel.app/api/generate';

client.on('messageCreate', async (message) => {
  if (message.author.bot) return;

  if (message.content.startsWith('!ff')) {
    const args = message.content.split(' ').slice(1);
    const deviceName = args.slice(0, -2).join(' ');
    const playStyle = args[args.length - 2];
    const experience = args[args.length - 1];

    try {
      const response = await axios.post(`${API_URL}/freefire`, {
        device_name: deviceName,
        play_style: playStyle,
        experience_level: experience,
        calculator_type: 'free'
      }, {
        headers: { 'x-api-key': API_KEY }
      });

      const { data } = response.data;
      const embed = new EmbedBuilder()
        .setColor('#FF6B35')
        .setTitle('Free Fire Sensitivity')
        .addFields(
          { name: 'General', value: `${data.general}`, inline: true },
          { name: 'Red Dot', value: `${data.redDot}`, inline: true },
          { name: 'Sniper', value: `${data.sniperScope}`, inline: true }
        );

      message.reply({ embeds: [embed] });
    } catch (error) {
      message.reply(`Error: ${error.message}`);
    }
  }
});

client.login('YOUR_BOT_TOKEN');

Example Usage

!ff iPhone 14 Pro aggressive advanced

Telegram Bot Integration

Create a Telegram bot using Python.

Setup

pip install python-telegram-bot requests

Bot Code

from telegram import Update
from telegram.ext import Application, CommandHandler, ContextTypes
import requests

API_KEY = 'sk_your_key_here'
API_URL = 'https://gamingsensitivity.vercel.app/api/generate'

async def freefire(update: Update, context: ContextTypes.DEFAULT_TYPE):
    device_name = ' '.join(context.args[:-2])
    play_style = context.args[-2]
    experience = context.args[-1]

    response = requests.post(
        f'{API_URL}/freefire',
        json={
            'device_name': device_name,
            'play_style': play_style,
            'experience_level': experience,
            'calculator_type': 'free'
        },
        headers={'x-api-key': API_KEY}
    )
    
    data = response.json()
    settings = data['data']
    
    message = f"""Free Fire Sensitivity
    
General: {settings['general']}
Red Dot: {settings['redDot']}
Sniper: {settings['sniperScope']}"""
    
    await update.message.reply_text(message)

app = Application.builder().token('YOUR_BOT_TOKEN').build()
app.add_handler(CommandHandler("ff", freefire))
app.run_polling()

WhatsApp Bot Integration

Create a WhatsApp bot using Baileys.

Setup

npm install @whiskeysockets/baileys axios

Bot Code

const { default: makeWASocket, useMultiFileAuthState } = require('@whiskeysockets/baileys');
const axios = require('axios');

const API_KEY = 'sk_your_key_here';
const API_URL = 'https://gamingsensitivity.vercel.app/api/generate';
async function startBot() {
const { state, saveCreds } = await useMultiFileAuthState('auth');
const sock = makeWASocket({
auth: state,
printQRInTerminal: true
});
sock.ev.on('creds.update', saveCreds);
sock.ev.on('messages.upsert', async ({ messages }) => {
const msg = messages[0];
if (!msg.message || msg.key.fromMe) return;
const text = msg.message.conversation;
if (text.startsWith('!ff')) {
  const args = text.split(' ').slice(1);
  const deviceName = args.slice(0, -2).join(' ');
  const playStyle = args[args.length - 2];
  const experience = args[args.length - 1];

  const response = await axios.post(`${API_URL}/freefire`, {
    device_name: deviceName,
    play_style: playStyle,
    experience_level: experience,
    calculator_type: 'free'
  }, {
    headers: { 'x-api-key': API_KEY }
  });

  const { data } = response.data;
  const reply = `Free Fire Sensitivity\n\nGeneral: ${data.general}\nRed Dot: ${data.redDot}\nSniper: ${data.sniperScope}`;
  
  await sock.sendMessage(msg.key.remoteJid, { text: reply });
}
});
}
startBot();

Python Script Integration

Simple Python script to call the API.

import requests
API_KEY = 'sk_your_key_here'
url = 'https://gamingsensitivity.vercel.app/api/generate/freefire'
headers = {
'Content-Type': 'application/json',
'x-api-key': API_KEY
}
payload = {
'device_name': 'iPhone 14 Pro',
'play_style': 'aggressive',
'experience_level': 'advanced',
'calculator_type': 'free'
}
response = requests.post(url, json=payload, headers=headers)
data = response.json()
if data['success']:
settings = data['data']
print(f"General: {settings['general']}")
print(f"Red Dot: {settings['redDot']}")
print(f"Sniper: {settings['sniperScope']}")

Patch Notes - Version 5.0

Release Date: December 21, 2025

FREE Calculator - Version 5.0

Play Style Guide

Understanding your play style is crucial for optimal sensitivity settings. Choose the one that best matches how you play:

AGGRESSIVE

Best For: Players who love to push enemies and take fights head-on

• Rush into combat without hesitation
• Prefer close-to-mid range gunfights
• Like to pressure enemies constantly
• Perfect for squad leaders and entry fraggers

Sensitivity Type: Higher general sensitivity for quick turns and fast flicks

RUSHER

Best For: Ultra-fast players who prioritize speed over everything

• Always first to fight, fastest rotations
• Jump into hot drops without fear
• Non-stop movement and aggressive pushes
• W-key players who never stop attacking

Sensitivity Type: Maximum speed settings for lightning-fast reactions

PRECISE

Best For: Players who value accuracy and controlled gunfire

• Prefer to land every shot rather than spray
• Focus on headshots and precise aim
• Take time to line up shots perfectly
• Play calculated and methodical

Sensitivity Type: Lower sensitivity for maximum accuracy and recoil control

SNIPER

Best For: Long-range specialists and AWM/M82B mains

• Prefer to engage from distance
• Excel at long-range eliminations
• Camp in strong positions
• Love bolt-action rifles and DMRs

Sensitivity Type: Optimized for scoped weapons with stable long-range aim

BALANCED

Best For: All-around players who adapt to any situation

• Can rush when needed, camp when required
• Comfortable with all weapon types
• Switch between playstyles mid-game
• Jack of all trades

Sensitivity Type: Middle-ground settings that work in all scenarios

VERSATILE

Best For: Flexible players who constantly change tactics

• Master of adaptation
• Switch weapons and positions frequently
• Read the game and adjust strategy
• Support player who fills any role

Sensitivity Type: Dynamic settings for quick strategy changes

DEFENSIVE

Best For: Strategic players who prefer positioning over aggression

• Hold strong positions and angles
• React to enemy pushes rather than pushing first
• Excellent game sense and patience
• Team anchor and support player

Sensitivity Type: Stable sensitivity for holding positions and controlled fights

New in Version 5.0 (FREE)

Enhanced Device Detection

• Improved Apple device recognition (iPhone & iPad)
• Better Android brand detection
• Lag compensation for budget devices
• Performance-based optimizations

Advanced Customization Options

Now supports additional preferences:

• Drag Speed: Fast / Medium / Slow - Fast draggers get lower sens for better control
• Weapon Type: Shotgun / SMG / AR / One-Tap - Each weapon type gets optimized sensitivity
• Finger Configuration: 2-Finger / 3-Finger / 4-Finger - More fingers = lower sens for better control
• Aim Assist: Default / Precise - Precise mode (no assist) gets higher sensitivity
• Shooting Style: Drag / One-Tap / Hybrid - One-tap gets lower sens for precision

Smart Recommendations

• Recommended DPI based on your device performance
• Fire Button Size optimized for your screen
• Drag Angle set to optimal 37.5° for best control

VIP Calculator - Version 5.0

7-Day Optimization System

• Sensitivity improves automatically over 7 days
• Learns your device's capabilities
• Progressive enhancement system
• Maximum optimization after one week

Advanced Device Detection

• Brand-Specific Optimization: Samsung, Google, OnePlus, Xiaomi, ASUS ROG, and more
• Flagship Recognition: Automatically detects Pro/Max/Ultra models
• Gaming Phone Priority: Special settings for ROG, OnePlus gaming editions
• Tablet Optimization: iPad and Android tablets get unique calculations

Performance-Based Intelligence

• RAM Analysis: 4GB, 6GB, 8GB, 12GB+ optimizations
• Refresh Rate Detection: 60Hz, 90Hz, 120Hz, 144Hz, 240Hz+
• Touch Sampling Rate: Ultra-responsive on 240Hz+ devices
• Age Compensation: Newer devices get slight performance boost

Precision Scope System

• Device Tier Adjustments: Budget, Mid-range, High-end, Flagship
• Apple-Specific Ratios: Optimized for iOS devices
• Performance-Based Scaling: Better devices get tighter scope ratios
• Professional-Grade Tuning: Tournament-ready settings

VIP DPI System

• Smart DPI Recommendations: 450-600 range based on device
• RAM-Based Calculation: Higher RAM = Higher safe DPI
• Performance Scaling: Flagship devices get premium DPI settings
• Safe Boundaries: Never exceeds device capabilities

Experience Level Guide

Choose your skill level honestly for best results:

• Beginner: Just started playing (0-1 months)
• Novice: Learning the basics (1-3 months)
• Intermediate: Getting comfortable (3-6 months)
• Casual: Play for fun, not grinding (any time)
• Advanced: Skilled and confident (6+ months)
• Experienced: Very skilled player (1+ years)
• Professional: Competitive player / Scrims
• Expert: Tournament level / Content creator

Technical Improvements

FREE Calculator

• Simplified device detection (Apple vs Android)
• Basic lag compensation for budget devices
• Standard performance adjustments
• Core sensitivity calculations
• Essential recommendations (DPI, Fire Button, Drag Angle)

VIP Calculator

• Advanced 10+ brand detection system
• Time-based progressive optimization
• Refresh rate + touch sampling intelligence
• RAM + GPU + Processor combined analysis
• Age-based device compensation
• Flagship vs budget tier detection
• Professional-grade scope calculations
• Gaming phone special treatment
• Tablet-specific optimizations

Supported Devices

Fully Optimized:

• All iPhone models (6 and newer)
• All iPad models
• Samsung Galaxy series
• Google Pixel series
• OnePlus (all models)
• Xiaomi / Redmi / POCO
• OPPO / Realme
• VIVO / iQOO
• ASUS ROG Phone
• All Android devices (generic optimization)

Tips for Best Results

• Be Honest About Your Play Style - Don't choose "Aggressive" if you actually camp
• Try Different Styles - Experiment to find what truly fits you
• Choose Your Experience Correctly - Don't overestimate or underestimate
• VIP Users: Wait 7 days for full optimization to kick in
• Test in Training Mode - Always test before ranked games
• Adjust Fire Button Size - Use recommendations but trust your comfort
• Match Your Drag Speed - Fast draggers does not equal high sensitivity

FREE vs VIP Comparison

Bug Fixes

• Fixed scope multipliers for high-end devices
• Improved Apple device detection accuracy
• Better performance score calculations
• Enhanced bounds checking (50-200 range)
• Optimized drag angle calculations

Coming Soon

• Mouse DPI converter for emulator players
• Custom sensitivity profiles
• Sensitivity comparison tool
• Pro player sensitivity database

Remember: The best sensitivity is the one YOU'RE comfortable with. These are optimized starting points - adjust to your preference!

Version 5.0 - December 2025 - OB51 Compatible

Request Business API Key

Need higher rate limits and dedicated support? Request a Business API Key by sending an email with the following template:

Email Template

Hello,
I am [Your Full Name] from [Your Company/Organization Name].
I would like to request a Business API Key for the Gaming Sensitivity Calculator API.
Purpose/Use Case:
[Explain how you plan to use the API - e.g., integrating into a mobile app, Discord bot with large user base, web service, etc.]
Expected Usage:

Estimated requests per day: [Number]
Target audience: [Description]
Launch date: [Date]

Additional Information:
[Any other relevant details about your project]
Contact Information:

Email: [Your Email]
Telegram: [Your Telegram Username] (Optional)
Website/Portfolio: [URL] (Optional)

Thank you for considering my request.
Best regards,
[Your Name]

What to Expect

• Response Time: Within 24-48 hours
• Review Process: We'll review your use case and expected usage
• Custom Pricing: Business tier pricing will be provided based on your needs
• Dedicated Support: Priority support via email and Telegram

Business Tier Benefits

Best Practices

Security

• Never expose your API key in client-side code or public repositories
• Store API keys in environment variables
• Use HTTPS for all requests
• Rotate API keys periodically

Rate Limiting

• Monitor rate limit headers in responses
• Implement exponential backoff for retry logic
• Cache responses when possible
• Upgrade tier if consistently hitting limits

Error Handling

• Always check response status codes
• Implement proper error handling for all API calls
• Log errors for debugging
• Provide user-friendly error messages

Performance

• Batch requests when possible
• Use connection pooling for multiple requests
• Implement timeout handling
• Cache frequently requested data