> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flowx.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Force platform rescan

> Trigger a forced rescan of the platform to discover and refresh all available services and configurations

> [!WARNING]
>
> **Reference under review.** This endpoint is part of the platform health/discovery surface (Kubernetes-aware). It is an admin / operations endpoint, not a public integration API. For supported integration patterns, see [Consuming FlowX from external apps](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/consuming-flowx-from-external-apps.md).

The Force Platform Rescan API endpoint allows you to trigger an immediate rescan of the FlowX platform to discover new or updated services, configurations, and components. This is particularly useful when you've deployed new services or made configuration changes that need to be immediately recognized by the platform.

> [!NOTE]
>
> This endpoint performs a comprehensive scan of the platform infrastructure and may take some time to complete depending on your platform size and complexity.

## Endpoint

```bash cURL theme={"dark"}
curl -X GET '{baseUrl}/api/platform/discover' \
  -H 'Authorization: Bearer YOUR_API_TOKEN' \
  -H 'Cache-Control: no-cache' \
  -H 'Accept: */*'
```

**baseUrl** `string` *required*

The base URL of your FlowX platform instance

## Headers

**Authorization** `string` *required*

Bearer token for API authentication. Format: `Bearer YOUR_API_TOKEN`

**Cache-Control** `string` (default: no-cache)

Controls caching behavior. Recommended to use `no-cache` to ensure fresh discovery results

**Accept** `string` (default: */*)

Specifies the media types that are acceptable for the response

**User-Agent** `string`

Identifies the client application making the request

**Accept-Encoding** `string` (default: gzip, deflate, br)

Specifies the content encoding that the client can understand

## Response

```json Success Response theme={"dark"}
{
  "scanTimestamp": "2024-10-09T14:32:15.847Z",
  "totalServices": 15,
  "healthyServices": 14,
  "unhealthyServices": 1,
  "services": {
    "flowxEngine": {
      "name": "FlowX Engine",
      "version": "5.1.0",
      "status": "healthy",
      "endpoint": "http://flowx-engine:8080",
      "capabilities": ["process-execution", "workflow-management", "business-rules"],
      "lastHealthCheck": "2024-10-09T14:32:10Z"
    },
    "flowxDesigner": {
      "name": "FlowX Designer",
      "version": "5.1.0", 
      "status": "healthy",
      "endpoint": "http://flowx-designer:3000",
      "capabilities": ["process-design", "ui-design", "form-builder"],
      "lastHealthCheck": "2024-10-09T14:32:11Z"
    },
    "flowxAdmin": {
      "name": "FlowX Admin",
      "version": "5.1.0",
      "status": "healthy", 
      "endpoint": "http://flowx-admin:4000",
      "capabilities": ["user-management", "system-config", "monitoring"],
      "lastHealthCheck": "2024-10-09T14:32:12Z"
    },
    "flowxCms": {
      "name": "FlowX CMS",
      "version": "5.1.0",
      "status": "healthy",
      "endpoint": "http://flowx-cms:5000",
      "capabilities": ["content-management", "localization", "asset-management"],
      "lastHealthCheck": "2024-10-09T14:32:13Z"
    },
    "documentManagement": {
      "name": "Document Management Plugin",
      "version": "5.1.0",
      "status": "healthy",
      "endpoint": "http://document-plugin:8081",
      "capabilities": ["document-storage", "file-processing", "document-templates"],
      "lastHealthCheck": "2024-10-09T14:32:14Z"
    },
    "notifications": {
      "name": "Notifications Plugin", 
      "version": "5.1.0",
      "status": "unhealthy",
      "endpoint": "http://notifications-plugin:8082",
      "capabilities": ["email-notifications", "sms-notifications", "push-notifications"],
      "lastHealthCheck": "2024-10-09T14:30:00Z",
      "error": "Connection timeout - service may be down"
    },
    "taskManagement": {
      "name": "Task Management Plugin",
      "version": "5.1.0", 
      "status": "healthy",
      "endpoint": "http://task-plugin:8083",
      "capabilities": ["task-assignment", "task-tracking", "workflow-integration"],
      "lastHealthCheck": "2024-10-09T14:32:15Z"
    }
  },
  "infrastructure": {
    "database": {
      "type": "PostgreSQL",
      "version": "13.7",
      "status": "healthy",
      "connections": {
        "active": 45,
        "idle": 15,
        "max": 100
      },
      "lastHealthCheck": "2024-10-09T14:32:00Z"
    },
    "messageBroker": {
      "type": "Apache Kafka",
      "version": "3.4.0",
      "status": "healthy", 
      "brokers": 3,
      "topics": 28,
      "lastHealthCheck": "2024-10-09T14:32:05Z"
    },
    "redis": {
      "type": "Redis",
      "version": "7.0.11",
      "status": "healthy",
      "memory": {
        "used": "245MB",
        "available": "1GB"
      },
      "lastHealthCheck": "2024-10-09T14:32:08Z"
    }
  },
  "externalIntegrations": {
    "authProvider": {
      "name": "Keycloak",
      "status": "healthy",
      "endpoint": "https://auth.company.com",
      "lastHealthCheck": "2024-10-09T14:32:00Z"
    },
    "documentStorage": {
      "name": "MinIO S3",
      "status": "healthy", 
      "endpoint": "https://storage.company.com",
      "buckets": 12,
      "lastHealthCheck": "2024-10-09T14:32:02Z"
    }
  },
  "summary": {
    "scanDuration": "4.2s",
    "newServicesFound": 0,
    "configurationChanges": 2,
    "issuesDetected": 1,
    "recommendations": [
      "Check notifications plugin connectivity",
      "Consider scaling database connections"
    ]
  }
}
```

**scanTimestamp** `string`

ISO 8601 formatted timestamp of when the platform rescan was completed

**totalServices** `integer`

Total number of services discovered during the rescan

**healthyServices** `integer`

Number of services that are currently healthy and operational

**unhealthyServices** `integer`

Number of services that are experiencing issues or are unreachable

**services** `object`

Detailed information about all discovered FlowX platform services

**Service details**

**flowxEngine** `object`

Core FlowX Engine service information

**Engine properties**

**name** `string`

Display name of the service

**version** `string`

Current version of the service

**status** `string`

Health status: `healthy`, `unhealthy`, or `unknown`

**endpoint** `string`

Service endpoint URL for internal communication

**capabilities** `array`

List of capabilities provided by this service

**lastHealthCheck** `string`

Timestamp of the most recent health check

**flowxDesigner** `object`

FlowX Designer service for process and UI design

**flowxAdmin** `object`

FlowX Admin service for system administration

**flowxCms** `object`

FlowX CMS service for content management

**documentManagement** `object`

Document Management Plugin service

**notifications** `object`

Notifications Plugin service (may include error details if unhealthy)

**taskManagement** `object`

Task Management Plugin service

**infrastructure** `object`

Information about underlying infrastructure components

**Infrastructure details**

**database** `object`

Database system information including connection pool status

**Database properties**

**type** `string`

Database type (e.g., PostgreSQL, MySQL)

**version** `string`

Database version

**status** `string`

Database health status

**connections** `object`

Connection pool statistics with active, idle, and maximum connections

**messageBroker** `object`

Message broker information including cluster status

**redis** `object`

Redis cache information including memory usage

**externalIntegrations** `object`

Status of external system integrations

**Integration details**

**authProvider** `object`

Authentication provider (e.g., Keycloak, LDAP) connection status

**documentStorage** `object`

External document storage system status and metrics

**summary** `object`

Summary information about the rescan operation

**Summary details**

**scanDuration** `string`

Time taken to complete the platform rescan

**newServicesFound** `integer`

Number of new services discovered since the last scan

**configurationChanges** `integer`

Number of configuration changes detected

**issuesDetected** `integer`

Number of issues or problems identified during the scan

**recommendations** `array`

List of recommended actions based on scan results

## Error Responses

```json Authentication Error theme={"dark"}
{
  "error": "Unauthorized",
  "message": "Invalid or missing authentication token",
  "status": 401
}
```

```json Server Error theme={"dark"}
{
  "error": "Internal Server Error", 
  "message": "Platform rescan failed due to internal error",
  "status": 500,
  "details": "Connection timeout while discovering services"
}
```

## Usage Examples

### Basic Platform Rescan

```javascript Node.js theme={"dark"}
const axios = require('axios');

async function forcePlatformRescan() {
  try {
    const response = await axios.get(`${baseUrl}/api/platform/discover`, {
      headers: {
        'Authorization': `Bearer ${apiToken}`,
        'Cache-Control': 'no-cache'
      }
    });
    
    const scanResult = response.data;
    
    console.log(`Rescan completed in ${scanResult.summary.scanDuration}`);
    console.log(`Services: ${scanResult.healthyServices}/${scanResult.totalServices} healthy`);
    
    if (scanResult.summary.issuesDetected > 0) {
      console.warn(`Issues detected: ${scanResult.summary.issuesDetected}`);
      scanResult.summary.recommendations.forEach(rec => {
        console.warn(`- ${rec}`);
      });
    }
    
    return scanResult;
  } catch (error) {
    console.error('Rescan failed:', error.response?.data || error.message);
    throw error;
  }
}
```

```python Python theme={"dark"}
import requests

def force_platform_rescan(base_url, api_token):
    headers = {
        'Authorization': f'Bearer {api_token}',
        'Cache-Control': 'no-cache'
    }
    
    try:
        response = requests.get(f'{base_url}/api/platform/discover', headers=headers)
        response.raise_for_status()
        
        scan_result = response.json()
        
        print(f"Rescan completed in {scan_result['summary']['scanDuration']}")
        print(f"Services: {scan_result['healthyServices']}/{scan_result['totalServices']} healthy")
        
        if scan_result['summary']['issuesDetected'] > 0:
            print(f"Issues detected: {scan_result['summary']['issuesDetected']}")
            for recommendation in scan_result['summary']['recommendations']:
                print(f"- {recommendation}")
        
        return scan_result
    except requests.exceptions.RequestException as e:
        print(f"Rescan failed: {e}")
        raise
```

```bash cURL theme={"dark"}
# Basic rescan request
curl -X GET 'https://your-platform.com/api/platform/discover' \
  -H 'Authorization: Bearer YOUR_API_TOKEN' \
  -H 'Cache-Control: no-cache'

# With verbose output for debugging
curl -X GET 'https://your-platform.com/api/platform/discover' \
  -H 'Authorization: Bearer YOUR_API_TOKEN' \
  -H 'Cache-Control: no-cache' \
  -v
```

## When to Use Force Rescan

> [tab] Service Deployment
>
> **After deploying new services**
>
> Use force rescan when you've deployed new microservices or updated existing ones to ensure the platform recognizes all available endpoints and configurations.
>
> ```bash theme={"dark"}
> # After deployment
> kubectl apply -f new-service.yaml
> # Then trigger rescan
> curl -X GET '/api/platform/discover' -H 'Authorization: Bearer TOKEN'
> ```

> [tab] Configuration Updates
>
> **After configuration changes**
>
> Trigger a rescan when you've updated platform configurations, environment variables, or service registrations that need immediate recognition.

> [tab] Troubleshooting
>
> **When services aren't recognized**
>
> If the platform isn't detecting services or configurations that should be available, a force rescan can help resolve discovery issues.


## Related topics

- [Oracle Database](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/oracle-database.md)
- [PostgreSQL Database](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/postgresql-database.md)
- [Db2 Database](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/db2-database.md)
- [Indexing config guidelines](https://docs.flowx.ai/6.x/setup-guides/flowx-engine-setup-guide/configuring-elasticsearch-indexing/process-instance-indexing-config-guidelines.md)
- [Speech to Text setup](https://docs.flowx.ai/6.x/setup-guides/speech-to-text-setup.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.