Registration Date Lookup

Check when VK accounts were registered to identify new or suspicious accounts

The Registration Date feature allows you to look up when any VK user account was created. This is particularly useful for identifying newly created bot accounts or verifying account age.

Why Registration Date Matters

Account registration date is a key indicator for detecting bots and fake accounts:

• New accounts - Recently created accounts with high activity may be bots
• Age verification - Older accounts are generally more trustworthy
• Pattern detection - Multiple accounts created on the same date may indicate bot networks
• Context for analysis - Registration date helps interpret account behavior

How to Check Registration Date

Click the calendar icon in the action bar next to any VK user account to fetch their registration date.

Registration Date Button

The button shows different states:

// src/entrypoints/content/insertion-variants/shared/@markup-ui/action-bar.ts
if (isFetched) {
  actionUi.render({
    ariaLabel: "Скрыть дату регистрации",
    icon: "calendarOff",
    tooltip: true,
  });
} else if (isFetching) {
  actionUi.render({
    ariaLabel: "Загрузка даты регистрации",
    icon: "loaderCircle",
    iconClassName: "bn:animate-spin",
    tooltip: false,
  });
} else {
  actionUi.render({
    ariaLabel: "Дата регистрации",
    icon: "calendarDays",
    tooltip: true,
  });
}

Button States:

• Calendar icon - Click to fetch registration date
• Spinning loader - Currently fetching data
• Calendar off icon - Click to hide the displayed date

RegDateService

The Registration Date feature is powered by the RegDateService (src/entrypoints/background/@services/reg-date-service.ts).

How It Works

async obtain(vkDomain: VkDomain): Promise<RegDateInfo> {
  const vkId = await this.vkDomainResolver.resolve(vkDomain);
  
  if (!vkId) {
    return {
      checkedAt: isoDateTimeSchema.parse(undefined),
      problem: true,
      type: "bn:ext:invalid-payload",
      description: "Аккаунт с таким никнеймом не найден",
      fields: ["vkDomain"],
    };
  }
  
  if (!isPositiveVkId(vkId)) {
    return {
      checkedAt: isoDateTimeSchema.parse(undefined),
      problem: true,
      type: "bn:ext:invalid-payload",
      description: "Невозможно узнать дату регистрации у сообществ VK",
      fields: ["vkDomain"],
    };
  }
  
  // Check authentication
  const authStatus = this.authService.getAuthStatus();
  if (authStatus.state !== "valid") {
    return {
      checkedAt: isoDateTimeSchema.parse(undefined),
      problem: true,
      type: "bn:ext:invalid-access-code",
      description: "Чтобы получить дату регистрации, настройте доступ",
    };
  }
  
  if (!authStatus.permissionLookup.getRegDate) {
    return {
      checkedAt: isoDateTimeSchema.parse(undefined),
      problem: true,
      type: "bn:ext:missing-permission",
      description: "Чтобы получить дату регистрации, ваш код должен иметь очки или дополнительные уровни",
    };
  }
  
  // Fetch from API
  const outcome = await this.authService.fetchFromDynamicApiWithAccessCode(
    "getRegDate",
    { vkId },
  );
  
  return outcome;
}

Validation Steps

1. Domain Resolution - Converts VK nickname to numeric ID
2. Account Type Check - Ensures it’s a user account (not a community)
3. Authentication Check - Verifies valid access code
4. Permission Check - Confirms getRegDate permission
5. API Request - Fetches registration date from Botnadzor API

Return Types

The service returns either:

type RegDateInfo = 
  | { value: IsoDate | IsoDateTime; checkedAt: IsoDateTime; }
  | { problem: true; type: string; description: string; checkedAt: IsoDateTime; };

Success: Contains the registration date as ISO date or datetime

Error Types:

• bn:ext:invalid-payload - Account not found or is a community
• bn:ext:invalid-access-code - Need to configure authentication
• bn:ext:missing-permission - Need points or higher permission level

Caching System

The service includes an LRU (Least Recently Used) cache to optimize performance:

private readonly regDateCache: LRUCache<PositiveVkId, CachedRegDateInfo>;

constructor({ authService, vkDomainResolver }) {
  this.authService = authService;
  this.vkDomainResolver = vkDomainResolver;
  this.regDateCache = new LRUCache({ max: 1000 });
}

Cache Features

• Maximum size: 1000 entries
• Deduplication: Prevents duplicate requests for the same account
• Pending state: Uses a symbol to indicate ongoing requests
• Automatic waiting: If a request is in progress, waits for completion instead of duplicating

private async getFromCache(
  vkId: PositiveVkId,
): Promise<RegDateInfo | undefined> {
  let cachedValue: CachedRegDateInfo | undefined;
  while ((cachedValue = this.regDateCache.get(vkId)) === symbolForPending) {
    await delay(50);
  }
  return cachedValue;
}

This ensures:

• Fast lookups for previously checked accounts
• No redundant API calls
• Efficient memory usage

Displaying Registration Date

Once fetched, the registration date is displayed inline near the account:

// src/entrypoints/content/insertion-variants/shared/@markup-ui/reg-date.ts
export function mountUiWithRegDate({
  instanceLogger,
  placement,
  rootElement,
}): InsertionUi<{ regDate?: RegDateInfo }> | undefined {
  const { element } = createInsertionUi({
    className: cn(
      "bn:relative bn:text-[13px] bn:text-muted-foreground bn:italic"
    ),
    dxLabel: "regDate",
    placement,
    rootElement,
    tagName: "span",
  });
  
  return {
    element,
    render: ({ regDate }) => {
      if (regDate?.status === "fetched") {
        element.hidden = false;
        element.textContent = formatDate(regDate.value);
      } else {
        element.hidden = true;
        element.textContent = "";
      }
    },
    unmount: () => {
      element.remove();
    },
  };
}

The date appears as:

• Small italic text in muted color
• Positioned according to the insertion variant configuration
• Formatted according to locale settings
• Hidden when not fetched

Permission Requirements

To use the Registration Date feature, you need:

1. Valid authentication - Configured access code in extension settings
2. getRegDate permission - Obtained through:
   • Having points in your Botnadzor account
   • Higher permission levels

Error Notifications

If you lack permissions, you’ll see a notification:

void serviceLookup.notificationService.trigger(contentId, {
  message: regDate.description,
  type:
    regDate.type === "bn:ext:invalid-access-code"
      ? "regDateUnauthorized"
      : regDate.type === "bn:ext:missing-permission"
        ? "regDateMissingPermission"
        : "regDateUnavailable",
});

• regDateUnauthorized - Set up authentication in extension settings
• regDateMissingPermission - Need more points or higher access level
• regDateUnavailable - Other error occurred

Integration with Other Features

Registration date data is stored in the insertion instance’s inner data:

type AccountInnerData = {
  regDateInfo?: RegDateInfo;
};

onRegDateInfoChange: (regDateInfo) => {
  updateInnerData((draft) => {
    if (regDateInfo) {
      draft.regDateInfo = regDateInfo;
    } else {
      delete draft.regDateInfo;
    }
  });
}

This allows:

• Registration date to persist while viewing the page
• Other components to access the data
• State management through Immer draft updates

Limitations

• User accounts only - Cannot check registration date for VK communities (groups, pages)
• API rate limits - Subject to Botnadzor API quota
• Permission-gated - Requires active authentication and sufficient permissions
• Cache expiration - Cached dates are cleared when browser restarts

Use Cases

Identifying New Bot Accounts

1. Spot suspicious comment or activity
2. Check registration date
3. If account is very new (days/weeks old) with high activity → likely bot

Verifying Account Legitimacy

1. Encounter questionable account
2. Check registration date
3. Old account (years) → more likely legitimate
4. Consider in context with other indicators

Analyzing Bot Networks

1. Find multiple suspicious accounts
2. Check all registration dates
3. Accounts created on same day/week → possible coordinated bot network
4. Use as evidence when reporting