👥 Referral Interlink Airdrop + Script for auto claim token

Pesh · May 4, 2025

Interlink Auto Bot

==========
Steps to register

Register : You do not have permission to view the full content of this post. Log in or register now.
Download App & Install via Playstore or any store haha
Sign up » Create InterLink ID
Start FaceScan » Login
Claim $ITLG Welcome Bonus
Go to Profile > Refferal > Scrolldown
Submit : 07132022 ( 1,000 $ITLG token Instantly )
Done

Remember to submit my refcode in profile > referral to claim 1k token instantly, my code is 07132022
==========

Script Installation

Gawa kayo folder and then gawa kayo file sa folder nang index.js tas ito ilalagay nyo sa index.js na file naiyan
REMINDER: Make sure na ibahin nyu yung Device information nasa line 17 to 19, please change it as the same as your device information para hindi suspicious uki?

copy paste the code below and paste it through index.js na file

Code:

const axios = require('axios');
const fs = require('fs');
const path = require('path');
const moment = require('moment');
const readline = require('readline');
const { clear } = require('console');
const { HttpsProxyAgent } = require('https-proxy-agent');
const { SocksProxyAgent } = require('socks-proxy-agent');
const https = require('https');

const API_BASE_URL = 'https://prod.interlinklabs.ai/api/v1';
const TOKEN_FILE_PATH = path.join(__dirname, 'token.txt');
const PROXIES_FILE_PATH = path.join(__dirname, 'proxies.txt');

// Device information for user agent
const DEVICE_INFO = {
  manufacturer: 'Oppo',
  model: 'A15s',
  androidVersion: '10'
};

const USER_AGENT = `Dalvik/2.1.0 (Linux; U; Android ${DEVICE_INFO.androidVersion}; ${DEVICE_INFO.model} Build/TP1A.220624.014)`;

const colors = {
  green: '\x1b[32m',
  yellow: '\x1b[33m',
  red: '\x1b[31m',
  white: '\x1b[37m',
  gray: '\x1b[90m',
  cyan: '\x1b[36m',
  reset: '\x1b[0m',
  bold: '\x1b[1m'
};

const logger = {
  info: (msg) => console.log(`${colors.green}[✓] ${msg}${colors.reset}`),
  warn: (msg) => console.log(`${colors.yellow}[⚠] ${msg}${colors.reset}`),
  error: (msg) => console.log(`${colors.red}[✗] ${msg}${colors.reset}`),
  success: (msg) => console.log(`${colors.green}[✅] ${msg}${colors.reset}`),
  loading: (msg) => console.log(`${colors.cyan}[⟳] ${msg}${colors.reset}`),
  step: (msg) => console.log(`${colors.white}[➤] ${msg}${colors.reset}`),
  banner: () => {
    console.log(`${colors.cyan}${colors.bold}`);
    console.log(`---------------------------------------------`);
    console.log(`Interlink Auto Bot Upgraded Version - Pesh`);
    console.log(`---------------------------------------------${colors.reset}`);
    console.log();
  }
};

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

function promptInput(question) {
  return new Promise((resolve) => {
    rl.question(`${colors.white}${question}${colors.reset}`, (answer) => {
      resolve(answer.trim());
    });
  });
}

// Helper function to sleep for a specified number of milliseconds
function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

// Function to get a random delay between min and max seconds (in milliseconds)
function getRandomDelay(minSec, maxSec) {
  return Math.floor(Math.random() * (maxSec - minSec + 1) + minSec) * 1000;
}

// Function to determine if we should use a short or long delay
function shouldUseShortDelay() {
  // 70% chance of using a short delay (14-16 seconds)
  // 30% chance of using a long delay (1-3 hours)
  return Math.random() < 0.7;
}

// Function to get a human-like delay
function getHumanLikeDelay() {
  if (shouldUseShortDelay()) {
    // Short delay: 14-16 seconds
    return getRandomDelay(14, 16);
  } else {
    // Long delay: 1-3 hours (in seconds)
    return getRandomDelay(60 * 60, 3 * 60 * 60);
  }
}

// Format ms to human readable time with adaptive units
function formatDelay(ms) {
  if (ms < 60000) {
    // Less than a minute, show seconds
    return `${Math.round(ms / 1000)} seconds`;
  } else if (ms < 3600000) {
    // Less than an hour, show minutes
    return `${Math.round(ms / 60000)} minutes`;
  } else {
    // Show hours and minutes
    const hours = Math.floor(ms / 3600000);
    const minutes = Math.round((ms % 3600000) / 60000);
    return `${hours} hour${hours !== 1 ? 's' : ''} ${minutes > 0 ? `${minutes} min` : ''}`;
  }
}

async function sendOtp(apiClient, loginId, passcode, email) {
  try {
    const payload = { loginId, passcode, email };
    const response = await apiClient.post('/auth/send-otp-email-verify-login', payload);
    if (response.data.statusCode === 200) {
      logger.success(response.data.message);
      logger.info(`If OTP doesn't arrive, stop the bot (Ctrl+C) and restart.`);
    } else {
      logger.error(`Failed to send OTP: ${JSON.stringify(response.data)}`);
    }
  } catch (error) {
    logger.error(`Error sending OTP: ${error.response?.data?.message || error.message}`);
    if (error.response?.data) {
      logger.error(`Response details: ${JSON.stringify(error.response.data)}`);
    }
  }
}

async function verifyOtp(apiClient, loginId, otp) {
  try {
    const payload = { loginId, otp };
    const response = await apiClient.post('/auth/check-otp-email-verify-login', payload);
    if (response.data.statusCode === 200) {
      logger.success(response.data.message);
      const token = response.data.data.jwtToken;
      saveToken(token);
      return token;
    } else {
      logger.error(`Failed to verify OTP: ${JSON.stringify(response.data)}`);
      return null;
    }
  } catch (error) {
    logger.error(`Error verifying OTP: ${error.response?.data?.message || error.message}`);
    if (error.response?.data) {
      logger.error(`Response details: ${JSON.stringify(error.response.data)}`);
    }
    return null;
  }
}

function saveToken(token) {
  try {
    fs.writeFileSync(TOKEN_FILE_PATH, token);
    logger.info(`Token saved to ${TOKEN_FILE_PATH}`);
  } catch (error) {
    logger.error(`Error saving token: ${error.message}`);
  }
}

async function login(proxies) {
  const loginId = await promptInput('Enter your login ID (or email): ');
  const passcode = await promptInput('Enter your passcode: ');
  const email = await promptInput('Enter your email: ');

  let apiClient;
  const proxy = getRandomProxy(proxies);

  if (proxy) {
    logger.step(`Attempting to send OTP with proxy: ${proxy}`);
    apiClient = createApiClient(null, proxy);
  } else {
    logger.step(`Attempting to send OTP without proxy...`);
    apiClient = createApiClient(null);
  }

  await sendOtp(apiClient, loginId, passcode, email);
  const otp = await promptInput('Enter OTP: ');
  const token = await verifyOtp(apiClient, loginId, otp);

  return token;
}

function readToken() {
  try {
    return fs.readFileSync(TOKEN_FILE_PATH, 'utf8').trim();
  } catch (error) {
    logger.warn(`Token file not found or invalid. Will attempt login.`);
    return null;
  }
}

function readProxies() {
  try {
    if (!fs.existsSync(PROXIES_FILE_PATH)) {
      logger.warn(`Proxies file not found. Running without proxies.`);
      return [];
    }
   
    const content = fs.readFileSync(PROXIES_FILE_PATH, 'utf8');
    return content.split('\n')
      .map(line => line.trim())
      .filter(line => line && !line.startsWith('#'));
  } catch (error) {
    logger.error(`Error reading proxies file: ${error.message}`);
    return [];
  }
}

function getRandomProxy(proxies) {
  if (!proxies.length) return null;
  return proxies[Math.floor(Math.random() * proxies.length)];
}

function createProxyAgent(proxyUrl) {
  if (!proxyUrl) return null;

  if (proxyUrl.startsWith('socks://') || proxyUrl.startsWith('socks4://') || proxyUrl.startsWith('socks5://')) {
    return new SocksProxyAgent(proxyUrl);
  } else {
    return new HttpsProxyAgent(proxyUrl);
  }
}

function createApiClient(token, proxy = null) {
  const config = {
    baseURL: API_BASE_URL,
    headers: {
      'User-Agent': USER_AGENT,
      'Accept-Encoding': 'gzip',
      'X-Device-Model': DEVICE_INFO.model,
      'X-Device-Manufacturer': DEVICE_INFO.manufacturer,
      'X-Android-Version': DEVICE_INFO.androidVersion
    },
    timeout: 30000,
    httpsAgent: new https.Agent({
      rejectUnauthorized: false
    })
  };
 
  if (token) {
    config.headers['Authorization'] = `Bearer ${token}`;
  }
 
  if (proxy) {
    try {
      const proxyAgent = createProxyAgent(proxy);
      config.httpsAgent = proxyAgent;
      config.proxy = false;
      logger.info(`Using proxy: ${proxy}`);
    } catch (error) {
      logger.error(`Error setting up proxy: ${error.message}`);
    }
  }
 
  return axios.create(config);
}

function formatTimeRemaining(milliseconds) {
  if (milliseconds <= 0) return '00:00:00';
 
  const seconds = Math.floor((milliseconds / 1000) % 60);
  const minutes = Math.floor((milliseconds / (1000 * 60)) % 60);
  const hours = Math.floor((milliseconds / (1000 * 60 * 60)) % 24);
 
  return [hours, minutes, seconds]
    .map(val => val.toString().padStart(2, '0'))
    .join(':');
}

async function getCurrentUser(apiClient) {
  try {
    const response = await apiClient.get('/auth/current-user');
    return response.data.data;
  } catch (error) {
    logger.error(`Error getting user information: ${error.response?.data?.message || error.message}`);
    return null;
  }
}

async function getTokenBalance(apiClient) {
  try {
    const response = await apiClient.get('/token/get-token');
    return response.data.data;
  } catch (error) {
    logger.error(`Error getting token balance: ${error.response?.data?.message || error.message}`);
    return null;
  }
}

async function checkIsClaimable(apiClient) {
  try {
    const response = await apiClient.get('/token/check-is-claimable');
    return response.data.data;
  } catch (error) {
    logger.error(`Error checking if airdrop is claimable: ${error.response?.data?.message || error.message}`);
    return { isClaimable: false, nextFrame: Date.now() + 1000 * 60 * 5 };
  }
}

async function claimAirdrop(apiClient) {
  try {
    const response = await apiClient.post('/token/claim-airdrop');
    logger.success(`Airdrop claimed successfully!`);
    return response.data;
  } catch (error) {
    logger.error(`Error claiming airdrop: ${error.response?.data?.message || error.message}`);
    return null;
  }
}

function displayUserInfo(userInfo, tokenInfo) {
  if (!userInfo || !tokenInfo) return;
 
  console.log('\n' + '='.repeat(50));
  console.log(`${colors.yellow}${colors.bold}👤 USER INFORMATION${colors.reset}`);
  console.log(`${colors.yellow}Username:${colors.reset} ${userInfo.username}`);
  console.log(`${colors.yellow}Email:${colors.reset} ${userInfo.email}`);
  console.log(`${colors.yellow}Wallet:${colors.reset} ${userInfo.connectedAccounts?.wallet?.address || 'Not connected'}`);
  console.log(`${colors.yellow}User ID:${colors.reset} ${userInfo.loginId}`);
  console.log(`${colors.yellow}Referral ID:${colors.reset} ${tokenInfo.userReferralId}`);
 
  console.log('\n' + '='.repeat(50));
  console.log(`${colors.yellow}${colors.bold}💰 TOKEN BALANCE${colors.reset}`);
  console.log(`${colors.yellow}Gold Tokens:${colors.reset} ${tokenInfo.interlinkGoldTokenAmount}`);
  console.log(`${colors.yellow}Silver Tokens:${colors.reset} ${tokenInfo.interlinkSilverTokenAmount}`);
  console.log(`${colors.yellow}Diamond Tokens:${colors.reset} ${tokenInfo.interlinkDiamondTokenAmount}`);
  console.log(`${colors.yellow}Interlink Tokens:${colors.reset} ${tokenInfo.interlinkTokenAmount}`);
  console.log(`${colors.yellow}Last Claim:${colors.reset} ${moment(tokenInfo.lastClaimTime).format('YYYY-MM-DD HH:mm:ss')}`);
 
  // Display device info
  console.log('\n' + '='.repeat(50));
  console.log(`${colors.yellow}${colors.bold}📱 DEVICE INFORMATION${colors.reset}`);
  console.log(`${colors.yellow}Device:${colors.reset} ${DEVICE_INFO.manufacturer} ${DEVICE_INFO.model}`);
  console.log(`${colors.yellow}Android:${colors.reset} ${DEVICE_INFO.androidVersion}`);
  console.log('='.repeat(50) + '\n');
}

async function tryConnect(token, proxies) {
  let apiClient;
  let userInfo = null;
  let tokenInfo = null;
 
  logger.step(`Attempting connection without proxy...`);
  apiClient = createApiClient(token);
 
  logger.loading(`Retrieving user information...`);
  userInfo = await getCurrentUser(apiClient);
 
  if (!userInfo && proxies.length > 0) {
    let attempts = 0;
    const maxAttempts = Math.min(proxies.length, 5);
   
    while (!userInfo && attempts < maxAttempts) {
      const proxy = proxies[attempts];
      logger.step(`Trying with proxy ${attempts + 1}/${maxAttempts}: ${proxy}`);
     
      apiClient = createApiClient(token, proxy);
     
      logger.loading(`Retrieving user information...`);
      userInfo = await getCurrentUser(apiClient);
      attempts++;
     
      if (!userInfo) {
        logger.warn(`Proxy ${proxy} failed. Trying next...`);
      }
    }
  }
 
  if (userInfo) {
    logger.loading(`Retrieving token balance...`);
    tokenInfo = await getTokenBalance(apiClient);
  }
 
  return { apiClient, userInfo, tokenInfo };
}

async function runBot() {
  try {
    clear();
    logger.banner();
   
    const proxies = readProxies();
    let token = readToken();
   
    if (!token) {
      logger.step(`No token found. Initiating login...`);
      token = await login(proxies);
      if (!token) {
        logger.error(`Login failed. Exiting.`);
        process.exit(1);
      }
    }
   
    let { apiClient, userInfo, tokenInfo: initialTokenInfo } = await tryConnect(token, proxies);
   
    if (!userInfo || !initialTokenInfo) {
      logger.error(`Failed to retrieve necessary information. Attempting login...`);
      token = await login(proxies);
      if (!token) {
        logger.error(`Login failed. Exiting.`);
        process.exit(1);
      }
      const result = await tryConnect(token, proxies);
      apiClient = result.apiClient;
      userInfo = result.userInfo;
      initialTokenInfo = result.tokenInfo;
      if (!userInfo || !initialTokenInfo) {
        logger.error(`Failed to retrieve necessary information after login. Check your credentials and proxies.`);
        process.exit(1);
      }
    }
   
    let tokenInfo = initialTokenInfo;
   
    logger.success(`Connected as ${userInfo.username}`);
    logger.info(`Started at: ${moment().format('YYYY-MM-DD HH:mm:ss')}`);
    logger.info(`Device: ${DEVICE_INFO.manufacturer} ${DEVICE_INFO.model} (Android ${DEVICE_INFO.androidVersion})`);
   
    displayUserInfo(userInfo, tokenInfo);
   
    // Maintain a state for the bot
    let botState = {
      isClaimingInProgress: false,
      nextClaimTime: 0,
      scheduledDelay: 0,
      countdownInterval: null,
      scheduledTask: null
    };
   
    // Clear any existing timer
    function clearBotTimers() {
      if (botState.countdownInterval) {
        clearInterval(botState.countdownInterval);
        botState.countdownInterval = null;
      }
     
      if (botState.scheduledTask) {
        clearTimeout(botState.scheduledTask);
        botState.scheduledTask = null;
      }
    }
   
    // Display countdown timer
    function startCountdown(targetTime, message) {
      clearBotTimers();
     
      // Calculate initial remaining time
      const updateDisplay = () => {
        const now = Date.now();
        const timeRemaining = Math.max(0, targetTime - now);
       
        // Update console with countdown
        process.stdout.write(`\r${colors.white}⏱️ ${message}: ${colors.bold}${formatTimeRemaining(timeRemaining)}${colors.reset}     `);
       
        if (timeRemaining <= 0) {
          clearInterval(botState.countdownInterval);
          process.stdout.write('\n');
          return true;
        }
        return false;
      };
     
      // Initial display
      updateDisplay();
     
      // Update countdown every second
      botState.countdownInterval = setInterval(() => {
        updateDisplay();
      }, 1000);
    }
   
    // Function to handle the entire claim process
    async function handleClaimProcess() {
      // Don't start a new claim process if one is already running
      if (botState.isClaimingInProgress) return;
     
      try {
        botState.isClaimingInProgress = true;
       
        // Get fresh API client with random proxy when available
        let currentApiClient = apiClient;
        if (proxies.length > 0) {
          const randomProxy = getRandomProxy(proxies);
          currentApiClient = createApiClient(token, randomProxy);
        }
       
        // Check if airdrop is claimable
        const claimCheck = await checkIsClaimable(currentApiClient);
       
        if (claimCheck.isClaimable) {
          // Decide on a random human-like delay
          const delayMs = getHumanLikeDelay();
          const delayFormatted = formatDelay(delayMs);
         
          logger.loading(`Airdrop is claimable! Will claim in ${delayFormatted}`);
         
          // Start countdown for the delay
          const claimTime = Date.now() + delayMs;
          startCountdown(claimTime, "Claiming in");
         
          // Schedule the actual claim
          botState.scheduledTask = setTimeout(async () => {
            try {
              process.stdout.write('\n');
              logger.loading(`Now attempting to claim airdrop...`);
             
              // Attempt to claim
              await claimAirdrop(currentApiClient);
             
              // Refresh token info
              logger.loading(`Updating token information...`);
              const newTokenInfo = await getTokenBalance(currentApiClient);
              if (newTokenInfo) {
                tokenInfo = newTokenInfo;
                displayUserInfo(userInfo, tokenInfo);
              }
             
              // Get next check time from API response
              botState.nextClaimTime = claimCheck.nextFrame;
             
              // Start countdown to next check
              startCountdown(botState.nextClaimTime, "Next claim in");
             
              // Schedule next check
              scheduleNextCheck();
            } catch (error) {
              logger.error(`Error during claim process: ${error.message}`);
            } finally {
              botState.isClaimingInProgress = false;
            }
          }, delayMs);
         
        } else {
          // Not claimable, schedule next check
          botState.nextClaimTime = claimCheck.nextFrame;
         
          // Start countdown to next check
          startCountdown(botState.nextClaimTime, "Next claim in");
         
          // Schedule next check
          scheduleNextCheck();
          botState.isClaimingInProgress = false;
        }
      } catch (error) {
        logger.error(`Unexpected error in claim process: ${error.message}`);
        botState.isClaimingInProgress = false;
       
        // Attempt to recover
        setTimeout(() => handleClaimProcess(), 60000);
      }
    }
   
    // Schedule the next check
    function scheduleNextCheck() {
      if (botState.scheduledTask) {
        clearTimeout(botState.scheduledTask);
      }
     
      const now = Date.now();
      const timeUntilNextCheck = Math.max(1000, botState.nextClaimTime - now);
     
      botState.scheduledTask = setTimeout(() => {
        logger.step(`Scheduled check time reached.`);
        handleClaimProcess();
      }, timeUntilNextCheck);
    }
   
    // Start the initial claim process
    logger.step(`Checking if airdrop is claimable...`);
    await handleClaimProcess();
   
    logger.success(`Bot is running! Airdrop claims will be attempted automatically.`);
    logger.info(`Press Ctrl+C to exit`);
   
  } catch (error) {
    logger.error(`Unexpected error: ${error.message}`);
    process.exit(1);
  }
}

runBot().finally(() => rl.close());

After pasting the copied code sa index.js na file, open nyu cmd sa folder naiyan tas ito i ta-type nyo

Code:

npm install axios moment https-proxy-agent socks-proxy-agent

tas after lahat nyan,
AGAIN: EDIT THE DEVICE INFO // THIS IS THE MOST IMPORTANT PART

Start the bot

Code:

node .  // if di gumana just type node index.js

Screenshot when bot run

Script feature?:

Interlink Auto Bot Features

Automated Airdrop Claims: Automatically checks and claims available airdrops from the Interlink platform
Token Management: Tracks various token balances (Gold, Silver, Diamond, and Interlink tokens)
Human-like Behavior: Uses random delays between actions to mimic human behavior
Proxy Support: Rotates through proxy servers for request anonymization
Authentication System: Handles login, OTP verification, and token management
Real-time Countdown Timers: Displays time remaining until next claim
Detailed Logging: Color-coded console output for different types of information
Error Handling: Gracefully handles connection issues and API errors
Device Spoofing: Configures user agent and device information to appear as an Android device
Account Information Display: Shows detailed user and wallet information

The script creates a continuous claim cycle that attempts to maximize token collection while avoiding detection through its human-like timing patterns.

Use at your own risk, all risk are borne with the user. Enjoy

Pesh · May 4, 2025

comment lang po if may tanong haha ngayon lang naka post, busy kasi

Silentloki · May 4, 2025

crypto po to??

Pesh · May 4, 2025

Silentloki said:
crypto po to??

yes po

SomethingsNotRight · May 4, 2025

termux?

Pesh · May 4, 2025

SomethingsNotRight said:
termux?

pwede, just do
pkg install nodejs
pkg install git

and then follow the script installation

okay nayan

PHC-unknowndomain · May 4, 2025

pano paps kapag ganito?

Pesh · May 4, 2025

PHC-unknowndomain said:
pano paps kapag ganito?View attachment 3694443

may nodejs kanapoba?

if meron na do this

Code:

pkg update && pkg upgrade

Code:

pkg uninstall nodejs

Code:

pkg install nodejs

old version ata yan saiyo

PHC-unknowndomain · May 4, 2025

ty paps working

Pesh · May 4, 2025

PHC-unknowndomain said:
ty paps workingView attachment 3694469

noice noice, okay nayan, bili ka vps next time para di na mag on off on off

PHC-unknowndomain · May 4, 2025

Pesh said:
noice noice, okay nayan, bili ka vps next time para di na mag on off on off

paps required ba mag link ng wallet?

Pesh · May 4, 2025

PHC-unknowndomain said:
paps required ba mag link ng wallet?View attachment 3694470

dunno pero recommended ko na i link mo

jun123 · May 4, 2025

ingat lang sa paggmit ng auto ref script just always use proxy before apply dhil 80% chances of banning .

Pesh · May 4, 2025

jun123 said:
ingat lang sa paggmit ng auto ref script just always use proxy before apply dhil 80% chances of banning .

its not even an autoref script

its auto claim and don't worry, at the end of the line I always says Use at your own risk and indeed using proxy is the best way!!!love u boss mwamwa

jun123 · May 5, 2025

Pesh said:
its not even an autoref script its auto claim and don't worry, at the end of the line I always says Use at your own risk and indeed using proxy is the best way!!!love u boss mwamwa

gawan mona din apps pra mas lalo gnahan kmi mwamwa

Pesh · May 5, 2025

I have edited the script to have device function thingy(specific device, for example, android version 13, manufacturer: Itel, model: model of the phone) with a random delay when claiming is available, reply this comment and I'll comment you with the source code itself

lastn32 · May 5, 2025

yow boss

Pesh · May 5, 2025

lastn32 said:
yow boss

po?

lastn32 · May 5, 2025

Pesh said:
po?

done nako reg gamit ref mo

Pesh · May 5, 2025

lastn32 said:
done nako reg gamit ref mo

thank you po

👥 Referral Interlink Airdrop + Script for auto claim token

Honorary Poster

Interlink Auto Bot Features​

Honorary Poster

Fanatic

Honorary Poster

Forum Guru

Honorary Poster

Honorary Poster

Honorary Poster

Honorary Poster

Honorary Poster

Honorary Poster

Honorary Poster

Honorary Poster

Forum Veteran

Honorary Poster

Forum Veteran

Honorary Poster

About this Thread

Trending Topics

Online now

Forum statistics

Interlink Auto Bot Features