Aso-v2 NPM | npm.io

ASO-V2

ASO-V2 is a modern Node.js library for App Store Optimization (ASO) analysis. It helps you optimize your app's visibility on both Google Play and Apple App Store by providing detailed keyword analysis, competitor insights, and market opportunities.

This is a TypeScript rewrite and enhancement of the original ASO package with modern features, better error handling, and improved performance.

Features

🔍 Comprehensive keyword analysis
📊 Market saturation metrics
🏆 Competitor analysis
💡 Keyword suggestions
🔄 Cross-store support (Google Play & App Store)
📈 Traffic score calculation
🎯 Difficulty score assessment
⚡ Modern TypeScript implementation
🛡️ Robust error handling
🚦 Built-in rate limiting
💾 Optional request caching

Installation

npm install aso-v2

Quick Start

import { ASO } from 'aso-v2';

// For Google Play Store
const gplay = new ASO('gplay');

// For Apple App Store
const appStore = new ASO('itunes');

// Analyze a keyword
const analysis = await gplay.analyzeKeyword('fitness app');
console.log(analysis);

Basic Usage

Keyword Analysis

const analysis = await gplay.analyzeKeyword('fitness app');

// Results include:
{
  difficulty: {
    titleMatches: {
      exact: number,
      broad: number,
      partial: number,
      none: number,
      score: number
    },
    competitors: {
      count: number,
      score: number
    },
    // ... other metrics
    score: number
  },
  traffic: {
    suggest: {
      score: number
    },
    ranked: {
      count: number,
      avgRank: number,
      score: number
    },
    // ... other metrics
    score: number
  }
}

App Search

const results = await gplay.search({
  term: 'fitness tracker',
  num: 10,
  fullDetail: true
});

Get App Details

const appInfo = await gplay.getAppInfo('com.example.app');

Keyword Suggestions

const suggestions = await gplay.suggest({
  strategy: 'competition',
  appId: 'com.example.app',
  num: 30
});

Advanced Usage

Market Analysis

import { ASOAnalyzer } from 'aso-v2';

// Calculate market saturation
const saturation = ASOAnalyzer.calculateMarketSaturation(
  searchResults,
  10000 // minimum installs threshold
);

// Get competitive analysis
const analysis = ASOAnalyzer.analyzeCompetitiveGap(
  myApp,
  competitors
);

Keyword Combinations

const combinations = ASOAnalyzer.generateKeywordCombinations(
  ['fitness', 'workout', 'trainer'],
  100 // max length
);

Custom Configuration

const gplay = new ASO('gplay', {
  country: 'us',
  language: 'en',
  throttle: 1000, // milliseconds between requests
  timeout: 10000, // request timeout
  cache: true     // enable request caching
});

API Reference

ASO Class

Constructor

new ASO(store: 'gplay' | 'itunes', config?: StoreConfig)

Methods

analyzeKeyword(keyword: string): Promise<ScoreResult>
search(options: SearchOptions): Promise<SearchResult[]>
getAppInfo(appId: string): Promise<AppInfo>
getSimilarApps(appId: string, fullDetail?: boolean): Promise<AppInfo[]>
getSuggestions(term: string): Promise<string[]>
suggest(options: SuggestOptions): Promise<string[]>
getAppKeywords(appId: string): Promise<string[]>

ASOAnalyzer Class

Static methods for advanced analysis:

analyzeTitleMatches(keyword: string, apps: AppInfo[])
analyzeCompetitors(keyword: string, apps: AppInfo[])
calculateMarketSaturation(searchResults: SearchResult[], minInstalls?: number)
calculateKeywordRelevancy(keyword: string)
generateKeywordCombinations(keywords: string[], maxLength?: number)
analyzeCompetitiveGap(mainApp: AppInfo, competitors: AppInfo[])

Types

SearchOptions

interface SearchOptions {
  term: string;
  num?: number;
  fullDetail?: boolean;
  price?: 'all' | 'free' | 'paid';
  sortBy?: 'relevance' | 'rating' | 'newest';
}

SuggestOptions

interface SuggestOptions {
  strategy?: 'similar' | 'competition' | 'category' | 'arbitrary' | 'keywords';
  appId?: string;
  apps?: string[];
  keywords?: string[];
  num?: number;
}

StoreConfig

interface StoreConfig {
  country?: string;
  language?: string;
  throttle?: number;
  timeout?: number;
  cache?: boolean;
}

Error Handling

ASO-V2 includes robust error handling with retry mechanisms:

try {
  const analysis = await gplay.analyzeKeyword('fitness app');
} catch (error) {
  if (error.code === 'THROTTLED') {
    // Handle rate limiting
  }
  // Handle other errors
}

Best Practices

Use throttling to avoid rate limiting
Enable caching for repeated requests
Handle errors appropriately
Use fullDetail sparingly to reduce API calls
Batch operations when possible

Contributing

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -am 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Create a Pull Request

Credits

This is a TypeScript rewrite and enhancement of the original ASO package by Facundo Olano. The new version includes modern features, better error handling, TypeScript support, and improved performance while maintaining the core functionality of the original package.