List Applications

Overview

Retrieve a list of all Applications in your environment. View application configurations, enabled features, and processing capabilities.

Resource Access

User Permissions: Platform admin users only
Endpoint: GET /applications

Arguments

Parameter	Type	Required	Description
limit	integer	No	Number of results per page (default: 10, max: 100)
after_cursor	string	No	Return resources created after this cursor
before_cursor	string	No	Return resources created before this cursor

Example Request

curl -X GET \
  'https://api.ahrvo.network/payments/na/applications?limit=20' \
  -u username:password

Example Response

{
  "_embedded": {
    "applications": [
      {
        "id": "APc9vhYcPsRuTSpKD9KpMtPe",
        "created_at": "2024-11-14T22:25:06.54Z",
        "updated_at": "2024-11-14T22:26:29.53Z",
        "account_updater_enabled": false,
        "enabled": true,
        "name": "ACME Corp",
        "network_token_enabled": false,
        "owner": "IDjvxGeXBLKH1V9YnWm1CS4n",
        "processing_enabled": true,
        "settlement_enabled": true,
        "tags": {
          "environment": "production"
        },
        "_links": {
          "self": {
            "href": "https://api.ahrvo.network/payments/na/applications/APc9vhYcPsRuTSpKD9KpMtPe"
          },
          "processors": {
            "href": "https://api.ahrvo.network/payments/na/applications/APc9vhYcPsRuTSpKD9KpMtPe/processors"
          },
          "merchants": {
            "href": "https://api.ahrvo.network/payments/na/applications/APc9vhYcPsRuTSpKD9KpMtPe/merchants"
          },
          "application_profile": {
            "href": "https://api.ahrvo.network/payments/na/applications/APc9vhYcPsRuTSpKD9KpMtPe/application_profile"
          }
        }
      },
      {
        "id": "AP8s4Kd9m2NvLpRtQxYkFjWh",
        "created_at": "2024-10-20T15:30:00.00Z",
        "updated_at": "2024-11-01T10:00:00.00Z",
        "account_updater_enabled": true,
        "enabled": true,
        "name": "Tech Solutions Inc",
        "network_token_enabled": true,
        "owner": "IDz7rBcD3fGhJk5mNqPsXvYw",
        "processing_enabled": true,
        "settlement_enabled": true,
        "tags": {
          "environment": "staging"
        },
        "_links": {
          "self": {
            "href": "https://api.ahrvo.network/payments/na/applications/AP8s4Kd9m2NvLpRtQxYkFjWh"
          },
          "processors": {
            "href": "https://api.ahrvo.network/payments/na/applications/AP8s4Kd9m2NvLpRtQxYkFjWh/processors"
          },
          "merchants": {
            "href": "https://api.ahrvo.network/payments/na/applications/AP8s4Kd9m2NvLpRtQxYkFjWh/merchants"
          },
          "application_profile": {
            "href": "https://api.ahrvo.network/payments/na/applications/AP8s4Kd9m2NvLpRtQxYkFjWh/application_profile"
          }
        }
      }
    ]
  },
  "_links": {
    "self": {
      "href": "https://api.ahrvo.network/payments/na/applications?limit=20"
    },
    "next": {
      "href": "https://api.ahrvo.network/payments/na/applications?after_cursor=AP8s4Kd9m2NvLpRtQxYkFjWh&limit=20"
    }
  },
  "page": {
    "limit": 20,
    "next_cursor": "AP8s4Kd9m2NvLpRtQxYkFjWh"
  }
}

Response Fields

Field	Type	Description
id	string	Unique Application identifier (starts with "AP")
created_at	string	ISO 8601 timestamp when created
updated_at	string	ISO 8601 timestamp of last modification
name	string	Application name
owner	string	ID of the owner Identity
enabled	boolean	Whether Application is enabled
processing_enabled	boolean	Whether payment processing is enabled
settlement_enabled	boolean	Whether settlements are enabled
account_updater_enabled	boolean	Whether automatic card account updater is enabled
network_token_enabled	boolean	Whether network tokenization is enabled
tags	object	Key-value metadata
_links	object	HATEOAS links to related resources

Additional Information

Applications: Top-level resources
- Platform configuration containers
- Contain all merchants
- Usually one per platform
- Control payment processing settings
- Manage settlement behavior
Enabled Status: Active/inactive
- enabled: true: Application is active
- enabled: false: Application disabled (rare)
- Controls overall application access
- Different from processing_enabled
Processing Enabled: Payment processing
- true: Can process payments
- false: No payment processing (rare)
- Usually always enabled
- Contact support to modify
Settlement Enabled: Payout capability
- true: Can create settlements
- false: No automated settlements
- Usually always enabled
- Critical for merchant payouts
Account Updater: Card updates
- Automatic card information updates
- Reduces declined transactions
- Networks notify of card changes
- Seamless customer experience
Network Tokens: Enhanced security
- Card networks tokenize cards
- Better authorization rates
- Enhanced fraud protection
- PCI scope reduction
Pagination: Cursor-based
- Use limit for page size
- after_cursor for next page
- before_cursor for previous page
- Efficient for large datasets
Links: Related resources
- Processors: Payment processor configurations
- Merchants: All merchants under application
- Application Profile: Fee and risk settings
- Navigate between resources

Use Cases

List All Applications

curl -X GET \
  'https://api.ahrvo.network/payments/na/applications?limit=100' \
  -u username:password

View all platform applications
Audit application configurations
Check enabled features
Monitor application status

Find Application by Name

// Search for specific application
async function findApplicationByName(name) {
  const response = await fetch(
    'https://api.ahrvo.network/payments/na/applications?limit=100',
    {
      headers: {
        'Authorization': 'Basic ' + btoa('username:password')
      }
    }
  );
  
  const data = await response.json();
  const application = data._embedded.applications.find(
    app => app.name === name
  );
  
  if (application) {
    console.log(`Found: ${application.id}`);
    return application;
  } else {
    console.log('Application not found');
    return null;
  }
}

Check Feature Enablement

// Check which applications have advanced features
async function auditFeatureEnablement() {
  const response = await fetch(
    'https://api.ahrvo.network/payments/na/applications?limit=100',
    {
      headers: {
        'Authorization': 'Basic ' + btoa('username:password')
      }
    }
  );
  
  const data = await response.json();
  const apps = data._embedded.applications;
  
  console.log('Feature Enablement Report:\n');
  
  apps.forEach(app => {
    console.log(`${app.name} (${app.id}):`);
    console.log(`  Account Updater: ${app.account_updater_enabled ? '✓' : '✗'}`);
    console.log(`  Network Tokens: ${app.network_token_enabled ? '✓' : '✗'}`);
    console.log(`  Processing: ${app.processing_enabled ? '✓' : '✗'}`);
    console.log(`  Settlements: ${app.settlement_enabled ? '✓' : '✗'}`);
    console.log('');
  });
}

Compare Environments

// Compare staging vs production applications
async function compareEnvironments() {
  const stagingResponse = await fetch(
    'http://gateway.ahrvo.network/payments/na/applications?limit=100',
    {
      headers: {
        'Authorization': 'Basic ' + btoa('staging_user:staging_pass')
      }
    }
  );
  
  const productionResponse = await fetch(
    'https://api.ahrvo.network/payments/na/applications?limit=100',
    {
      headers: {
        'Authorization': 'Basic ' + btoa('prod_user:prod_pass')
      }
    }
  );
  
  const stagingData = await stagingResponse.json();
  const productionData = await productionResponse.json();
  
  console.log('Environment Comparison:');
  console.log(`Staging: ${stagingData._embedded.applications.length} applications`);
  console.log(`Production: ${productionData._embedded.applications.length} applications`);
  
  // Compare features
  const stagingFeatures = stagingData._embedded.applications[0];
  const productionFeatures = productionData._embedded.applications[0];
  
  if (stagingFeatures && productionFeatures) {
    console.log('\nFeature Parity:');
    console.log(`Account Updater: ${stagingFeatures.account_updater_enabled === productionFeatures.account_updater_enabled ? '✓' : '✗'}`);
    console.log(`Network Tokens: ${stagingFeatures.network_token_enabled === productionFeatures.network_token_enabled ? '✓' : '✗'}`);
  }
}

Export Application List

// Export all applications to CSV
async function exportApplicationsToCSV() {
  const response = await fetch(
    'https://api.ahrvo.network/payments/na/applications?limit=100',
    {
      headers: {
        'Authorization': 'Basic ' + btoa('username:password')
      }
    }
  );
  
  const data = await response.json();
  const apps = data._embedded.applications;
  
  const csv = [
    'ID,Name,Owner,Enabled,Processing,Settlement,Account Updater,Network Tokens,Created,Updated',
    ...apps.map(app => [
      app.id,
      `"${app.name}"`,
      app.owner,
      app.enabled,
      app.processing_enabled,
      app.settlement_enabled,
      app.account_updater_enabled,
      app.network_token_enabled,
      app.created_at,
      app.updated_at
    ].join(','))
  ].join('\n');
  
  console.log(csv);
  return csv;
}

Monitor Application Status

// Check all applications are healthy
async function monitorApplications() {
  const response = await fetch(
    'https://api.ahrvo.network/payments/na/applications?limit=100',
    {
      headers: {
        'Authorization': 'Basic ' + btoa('username:password')
      }
    }
  );
  
  const data = await response.json();
  const apps = data._embedded.applications;
  
  const issues = [];
  
  apps.forEach(app => {
    if (!app.enabled) {
      issues.push(`${app.name}: Application disabled`);
    }
    if (!app.processing_enabled) {
      issues.push(`${app.name}: Processing disabled`);
    }
    if (!app.settlement_enabled) {
      issues.push(`${app.name}: Settlements disabled`);
    }
  });
  
  if (issues.length > 0) {
    console.error('⚠ Application Issues:');
    issues.forEach(issue => console.error(`  - ${issue}`));
    return false;
  } else {
    console.log('✓ All applications healthy');
    return true;
  }
}

Get Application for Merchant Onboarding

// Get primary application for merchant onboarding
async function getPrimaryApplication() {
  const response = await fetch(
    'https://api.ahrvo.network/payments/na/applications?limit=100',
    {
      headers: {
        'Authorization': 'Basic ' + btoa('username:password')
      }
    }
  );
  
  const data = await response.json();
  const apps = data._embedded.applications;
  
  // Filter to production, enabled applications
  const productionApps = apps.filter(app => 
    app.enabled &&
    app.processing_enabled &&
    app.settlement_enabled &&
    (app.tags.environment === 'production' || !app.tags.environment)
  );
  
  if (productionApps.length === 0) {
    console.error('No production applications found');
    return null;
  }
  
  // Usually there's only one
  const primaryApp = productionApps[0];
  
  console.log('Primary Application:');
  console.log(`  ID: ${primaryApp.id}`);
  console.log(`  Name: ${primaryApp.name}`);
  console.log(`  Account Updater: ${primaryApp.account_updater_enabled}`);
  console.log(`  Network Tokens: ${primaryApp.network_token_enabled}`);
  
  return primaryApp;
}

Best Practices

Cache Results: Reduce API calls

let cachedApplications = null;
let cacheTime = null;
const CACHE_TTL = 30 * 60 * 1000; // 30 minutes

async function getCachedApplications() {
  const now = Date.now();
  
  if (cachedApplications && cacheTime && (now - cacheTime < CACHE_TTL)) {
    console.log('Returning cached applications');
    return cachedApplications;
  }
  
  const response = await fetch(
    'https://api.ahrvo.network/payments/na/applications?limit=100',
    {
      headers: {
        'Authorization': 'Basic ' + btoa('username:password')
      }
    }
  );
  
  const data = await response.json();
  cachedApplications = data._embedded.applications;
  cacheTime = now;
  
  return cachedApplications;
}

One Application Per Platform: Usually
- Most platforms have one Application
- Application contains all merchants
- Use Application Profiles for different pricing tiers
- Multiple Applications only for special cases
Monitor Status: Track health
- Check enabled status
- Verify processing_enabled
- Confirm settlement_enabled
- Alert on changes
- Regular health checks

Document Application IDs: Critical reference

// Store in configuration
const config = {
  production: {
    applicationId: 'APc9vhYcPsRuTSpKD9KpMtPe',
    name: 'ACME Corp Production'
  },
  staging: {
    applicationId: 'AP8s4Kd9m2NvLpRtQxYkFjWh',
    name: 'ACME Corp Staging'
  }
};

Use Tags: Organize applications
- Tag with environment (production, staging)
- Add region information
- Include business unit
- Track ownership
- Filter by tags

Common Workflows

Application Inventory Report

// Generate comprehensive application report
async function generateApplicationReport() {
  const response = await fetch(
    'https://api.ahrvo.network/payments/na/applications?limit=100',
    {
      headers: {
        'Authorization': 'Basic ' + btoa('username:password')
      }
    }
  );
  
  const data = await response.json();
  const apps = data._embedded.applications;
  
  console.log('=== Application Inventory Report ===\n');
  console.log(`Total Applications: ${apps.length}\n`);
  
  // Status breakdown
  const enabled = apps.filter(a => a.enabled).length;
  const processing = apps.filter(a => a.processing_enabled).length;
  const settlement = apps.filter(a => a.settlement_enabled).length;
  
  console.log('Status:');
  console.log(`  Enabled: ${enabled} (${(enabled/apps.length*100).toFixed(1)}%)`);
  console.log(`  Processing: ${processing} (${(processing/apps.length*100).toFixed(1)}%)`);
  console.log(`  Settlement: ${settlement} (${(settlement/apps.length*100).toFixed(1)}%)`);
  
  // Feature adoption
  const accountUpdater = apps.filter(a => a.account_updater_enabled).length;
  const networkTokens = apps.filter(a => a.network_token_enabled).length;
  
  console.log('\nFeature Adoption:');
  console.log(`  Account Updater: ${accountUpdater} (${(accountUpdater/apps.length*100).toFixed(1)}%)`);
  console.log(`  Network Tokens: ${networkTokens} (${(networkTokens/apps.length*100).toFixed(1)}%)`);
  
  // List all applications
  console.log('\nApplications:');
  apps.forEach(app => {
    console.log(`\n  ${app.name} (${app.id})`);
    console.log(`    Owner: ${app.owner}`);
    console.log(`    Created: ${app.created_at}`);
    console.log(`    Updated: ${app.updated_at}`);
    console.log(`    Tags: ${JSON.stringify(app.tags)}`);
  });
}

Find Disabled Applications

// Find applications with issues
async function findDisabledApplications() {
  const response = await fetch(
    'https://api.ahrvo.network/payments/na/applications?limit=100',
    {
      headers: {
        'Authorization': 'Basic ' + btoa('username:password')
      }
    }
  );
  
  const data = await response.json();
  const apps = data._embedded.applications;
  
  const disabled = apps.filter(a => !a.enabled);
  const noProcessing = apps.filter(a => !a.processing_enabled);
  const noSettlement = apps.filter(a => !a.settlement_enabled);
  
  if (disabled.length > 0) {
    console.log('⚠ Disabled Applications:');
    disabled.forEach(a => console.log(`  - ${a.name} (${a.id})`));
  }
  
  if (noProcessing.length > 0) {
    console.log('\n⚠ Processing Disabled:');
    noProcessing.forEach(a => console.log(`  - ${a.name} (${a.id})`));
  }
  
  if (noSettlement.length > 0) {
    console.log('\n⚠ Settlement Disabled:');
    noSettlement.forEach(a => console.log(`  - ${a.name} (${a.id})`));
  }
  
  if (disabled.length === 0 && noProcessing.length === 0 && noSettlement.length === 0) {
    console.log('✓ No disabled applications found');
  }
}

Paginate All Applications

// Fetch all applications using pagination
async function getAllApplications() {
  let allApplications = [];
  let nextCursor = null;
  
  do {
    const params = new URLSearchParams({
      limit: 100,
      ...(nextCursor && { after_cursor: nextCursor })
    });
    
    const response = await fetch(
      `https://api.ahrvo.network/payments/na/applications?${params}`,
      {
        headers: {
          'Authorization': 'Basic ' + btoa('username:password')
        }
      }
    );
    
    const data = await response.json();
    allApplications = allApplications.concat(data._embedded.applications);
    nextCursor = data.page.next_cursor;
    
  } while (nextCursor);
  
  console.log(`Total applications fetched: ${allApplications.length}`);
  return allApplications;
}

Security Considerations

API Access: Control carefully
- Only platform admins can list applications
- Applications contain sensitive configuration
- Audit who accesses application list
- Monitor for unauthorized access
Application IDs: Not secret
- Application IDs are not sensitive
- Can be stored in configuration
- Used in API calls
- No need to encrypt
Owner Information: Identity reference
- Owner is Identity ID
- Links to business entity details
- Don't expose in public APIs
- Protect PII
Tags: Avoid sensitive data
- Use for organization only
- Don't store secrets in tags
- Visible to all admins
- Not encrypted

Error Responses

Unauthorized

{
  "status": 401,
  "message": "Unauthorized"
}

Invalid API credentials
Check username/password
Verify authentication

Forbidden

{
  "status": 403,
  "message": "Forbidden"
}

Not platform admin
Insufficient permissions
Contact administrator

Troubleshooting

Empty Results

Check you have created applications
Verify API credentials correct
Confirm correct environment
May be different platform

Missing Applications

Check pagination (use higher limit)
Verify application IDs
May be deleted (rare)
Check different environment

Slow Response

Reduce page size
Use pagination
Check network latency
API may be under load

POST /applications: Create new application
GET /applications/{id}: Fetch specific application
PUT /applications/{id}: Update application configuration
GET /applications/{id}/merchants: List merchants under application
GET /applications/{id}/processors: List payment processors

Overview​

Resource Access​

Arguments​

Example Request​

Example Response​

Response Fields​

Additional Information​

Use Cases​

List All Applications​

Find Application by Name​

Check Feature Enablement​

Compare Environments​

Export Application List​

Monitor Application Status​

Get Application for Merchant Onboarding​

Best Practices​

Common Workflows​

Application Inventory Report​

Find Disabled Applications​

Paginate All Applications​

Security Considerations​

Error Responses​

Unauthorized​

Forbidden​

Troubleshooting​

Empty Results​

Missing Applications​

Slow Response​

Related Endpoints​