Chapter 13: Integrating with BSN.cloud#

Introduction#

BSN.cloud (BrightSign Network cloud) is BrightSign’s cloud-based content management and device control platform. It provides a comprehensive solution for managing digital signage networks at scale, from single installations to enterprise deployments with thousands of players. This chapter covers BSN.cloud integration, including provisioning, content management, remote control, and API-based automation.

BSN.cloud Overview#

Cloud Architecture#

BSN.cloud uses a distributed cloud architecture with the following components:

Control Plane: Manages device registration, authentication, and command distribution
Content Delivery Network (CDN): Delivers media files and presentations to players
API Layer: RESTful APIs for programmatic access to all platform features
Database Layer: Stores device configurations, content metadata, and analytics
WebSocket Gateway: Enables real-time communication with connected devices

The architecture supports high availability and scales to accommodate networks of any size.

Service Tiers and Features#

BSN.cloud offers multiple service tiers:

bsn.Control (Free tier):

Basic device provisioning and activation
Remote diagnostics and control
Device health monitoring
Limited API access for device management
B-Deploy automated provisioning

bsn.Content (Paid subscription):

Full content management capabilities
BrightAuthor:connected presentation authoring
Content library with versioning
Scheduled content deployment
Advanced analytics and reporting
Full API access
Priority support

Enterprise:

Dedicated infrastructure
Custom SLA agreements
Advanced security features
White-label options
Premium support

Account Setup#

To get started with BSN.cloud:

Create an account at https://www.bsn.cloud
Verify your email address
Choose a service tier
Create your first network
Obtain API credentials (for programmatic access)

For API access, you’ll need client credentials:

1
2
3
4
5
6
// Request client credentials from BrightSign support
// Credentials include:
{
  "client_id": "your_client_id",
  "client_secret": "your_client_secret"
}

Organization Structure#

BSN.cloud uses a hierarchical organization model:

Person: Individual user account with email/password credentials
Network: Container for players, content, and presentations
- A network can have multiple users with different permission levels
- Players belong to exactly one network at a time
- Network creator becomes the administrator
Groups: Logical collections of players for targeted deployments
Roles: Define permissions for users within a network

User Management#

Manage users through the BSN.cloud web interface or REST API:

1
GET /2020/10/REST/Users/

Users can have various permission levels:

Administrator: Full network access
Contributor: Can create and modify content
Viewer: Read-only access
Custom Roles: Fine-grained permission control

Device Provisioning#

Player Registration#

Players can be registered through multiple methods:

Manual Registration (Web UI):

Log into BSN.cloud
Navigate to Devices section
Click “Add Device”
Enter serial number
Configure device settings

API-Based Registration:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
// Register a device using REST API
async function registerDevice(serialNumber, networkId, accessToken) {
  const response = await fetch('https://api.bsn.cloud/2020/10/REST/Devices', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      serial: serialNumber,
      name: `Player-${serialNumber}`,
      description: 'Digital signage player',
      // Additional device configuration
    })
  });

  return await response.json();
}

Activation Process#

When a BrightSign player boots without local content:

Player displays on-screen activation interface
User can enter activation code or wait for auto-provisioning
Player contacts BSN.cloud activation servers
If serial number is registered, player downloads setup package
Player configures itself and downloads assigned presentation
Player begins playback and maintains cloud connection

Network Configuration#

Configure network settings via Device Setup packages or API:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
// Configure network interface settings
const networkSettings = {
  networkInterfaces: [
    {
      interfaceType: 'ethernet',
      interfaceName: 'eth0',
      dhcp: true,
      metric: 100  // Interface priority (lower = higher priority)
    },
    {
      interfaceType: 'wifi',
      interfaceName: 'wlan0',
      dhcp: true,
      ssid: 'YourNetwork',
      passphrase: 'YourPassword',
      metric: 110
    }
  ]
};

Starting with BrightSignOS 8.4.6, interface metrics are automatically assigned:

Metric = (interface_index × 10) + 100
Lower metrics have higher priority
Range 100-199 reserved for BSN-managed interfaces

Security Certificates#

BSN.cloud uses TLS certificates for secure communication:

Server Certificates: BSN.cloud uses industry-standard CA certificates
Client Authentication: Players authenticate using OAuth2 device credentials
Certificate Pinning: Optional for enhanced security in sensitive deployments

Bulk Provisioning#

For large deployments, use B-Deploy API:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
// Bulk register devices
async function bulkRegisterDevices(serialNumbers, setupId, accessToken) {
  const devices = serialNumbers.map(serial => ({
    serialNumber: serial,
    deviceSetupId: setupId
  }));

  const response = await fetch('https://api.bdeploy.bsn.cloud/devices/bulk', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ devices })
  });

  return await response.json();
}

Content Management#

Content Library Organization#

BSN.cloud organizes content in a virtual file system:

/Root
├── Images
│   ├── Backgrounds
│   └── Logos
├── Videos
│   ├── Promotional
│   └── Instructional
└── Presentations
    ├── Retail
    └── Corporate

Navigate and manage content via API:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
// List content in a folder
async function listContent(virtualPath, accessToken) {
  const encodedPath = encodeURIComponent(virtualPath);
  const response = await fetch(
    `https://api.bsn.cloud/2020/10/REST/Content/Root/${encodedPath}/`,
    {
      headers: { 'Authorization': `Bearer ${accessToken}` }
    }
  );

  return await response.json();
}

Media Upload and Storage#

Upload content files to BSN.cloud:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
// Upload content file
async function uploadContent(file, virtualPath, accessToken) {
  const formData = new FormData();
  formData.append('file', file);
  formData.append('path', virtualPath);

  const response = await fetch('https://api.bsn.cloud/upload', {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${accessToken}` },
    body: formData
  });

  return await response.json();
}

Storage considerations:

Maximum file size: 5GB per file
Supported formats: All BrightSign-compatible media types
Storage quota based on subscription tier
CDN caching for optimized delivery

Content Versioning#

BSN.cloud maintains content version history:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
// Retrieve content metadata including version info
async function getContentInfo(contentId, accessToken) {
  const response = await fetch(
    `https://api.bsn.cloud/2020/10/REST/Content/${contentId}/`,
    {
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'Accept': 'application/json'
      }
    }
  );

  const content = await response.json();
  // Returns: { id, name, version, uploadDate, hash, size, ... }
  return content;
}

Metadata Management#

Add custom metadata tags to content:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Add tags to content
async function addContentTags(contentId, tags, accessToken) {
  const response = await fetch(
    `https://api.bsn.cloud/2020/10/REST/Content/${contentId}/Tags/`,
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(tags)
    }
  );

  return response.status === 204; // Success returns 204 No Content
}

// Example usage
await addContentTags(123, {
  'Category': 'Promotional',
  'Season': 'Winter',
  'Region': 'Northeast'
}, token);

Content Distribution#

BSN.cloud uses CDN-based distribution:

Content is cached at edge locations globally
Players download from nearest CDN node
Supports progressive download for large files
Bandwidth throttling available to manage network load
Delta updates minimize data transfer

Presentation Creation#

BrightAuthor:connected#

BrightAuthor:connected is the desktop authoring tool for BSN.cloud:

Key Features:

Visual timeline-based editing
Multi-zone layout support
Interactive state machine creation
Live data feed integration
Direct publishing to BSN.cloud

Workflow:

Launch BrightAuthor:connected
Sign in with BSN.cloud credentials
Create or open presentation
Add media zones and content
Configure interactivity and transitions
Publish to BSN.cloud network

Web-Based Authoring#

BSN.cloud provides web-based presentation editing:

Template-based creation
Drag-and-drop interface
Preview before deployment
Mobile-friendly interface
Collaboration features

Interactive Presentations#

Create interactive experiences:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// Example presentation with interactive zones
const presentation = {
  name: 'Interactive Retail Display',
  zones: [
    {
      id: 'video_zone',
      type: 'VideoOrImages',
      width: 1920,
      height: 1080,
      playlist: [
        { type: 'video', contentId: 456 }
      ]
    },
    {
      id: 'touch_zone',
      type: 'EnhancedAudio',
      width: 400,
      height: 1080,
      enableTouch: true,
      events: [
        {
          trigger: 'touch',
          action: 'transitionToState',
          targetState: 'product_details'
        }
      ]
    }
  ]
};

Multi-Zone Layouts#

Define complex screen layouts:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
// Create multi-zone presentation
async function createPresentation(presentationData, accessToken) {
  const response = await fetch(
    'https://api.bsn.cloud/2020/10/REST/Presentations/',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(presentationData)
    }
  );

  return await response.json();
}

Scheduling and Playlists#

Schedule content playback:

Time-based scheduling: Play content at specific times
Day-part scheduling: Different content for different times of day
Date ranges: Seasonal or promotional content
Dynamic playlists: Content based on data feeds or tags

Remote Deployment#

Publishing Workflows#

Deploy presentations to players:

Create/Update Presentation: Author or modify content
Assign to Players: Target specific devices or groups
Schedule Deployment: Immediate or scheduled publication
Monitor Progress: Track download and activation status

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Publish presentation to devices
async function publishPresentation(presentationId, deviceIds, accessToken) {
  // Assign presentation to devices
  for (const deviceId of deviceIds) {
    await fetch(
      `https://api.bsn.cloud/2020/10/REST/Devices/${deviceId}/`,
      {
        method: 'PATCH',
        headers: {
          'Authorization': `Bearer ${accessToken}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify([
          {
            op: 'replace',
            path: '/currentPresentation',
            value: presentationId
          }
        ])
      }
    );
  }
}

Content Synchronization#

Players synchronize content automatically:

Check-in Interval: Players contact BSN.cloud periodically (default: 15 minutes)
Change Detection: Players download only modified content
Hash Verification: Content integrity verified using SHA256
Retry Logic: Failed downloads automatically retry with exponential backoff

Bandwidth Management#

Control network bandwidth usage:

Download Scheduling: Limit downloads to off-peak hours
Rate Limiting: Throttle download speeds
Progressive Download: Stream large files while playing
Bandwidth Monitoring: Track data usage per device

Progressive Downloads#

For large media files:

1
2
3
4
5
6
7
8
// Configure progressive download settings
const playerSettings = {
  downloadSettings: {
    enableProgressiveDownload: true,
    bufferSize: 10485760, // 10MB buffer
    maxConcurrentDownloads: 2
  }
};

Offline Fallback#

Players continue operation during network outages:

Local Caching: All content cached on storage
Offline Mode: Players continue with last successful content
Reconnection: Automatic reconnection when network restored
Sync on Reconnect: Download pending updates when back online

Device Management#

Remote Monitoring#

Monitor device status via API:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Get device status
async function getDeviceStatus(deviceId, accessToken) {
  const response = await fetch(
    `https://api.bsn.cloud/2020/10/REST/Devices/${deviceId}/`,
    {
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'Accept': 'application/json'
      }
    }
  );

  const device = await response.json();

  // Device status includes:
  // - lastCheckIn: Last communication time
  // - firmwareVersion: Current OS version
  // - model: Player model
  // - networkInterfaces: Network configuration and status
  // - storage: Storage capacity and usage
  // - currentPresentation: Active presentation

  return device;
}

Health Checks#

BSN.cloud performs automated health checks:

Connectivity: Device online/offline status
Storage: Available storage space
Temperature: Device operating temperature (if supported)
Playback: Current playback status
Errors: Error logs and diagnostics

Diagnostics#

Access detailed diagnostic information:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
// Get device errors
async function getDeviceErrors(deviceId, accessToken) {
  const response = await fetch(
    `https://api.bsn.cloud/2020/10/REST/Devices/${deviceId}/Errors/`,
    {
      headers: { 'Authorization': `Bearer ${accessToken}` }
    }
  );

  const errors = await response.json();
  return errors;
}

Remote Snapshots#

Capture screenshots remotely:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
// Retrieve latest screenshot
async function getDeviceScreenshot(deviceId, accessToken) {
  const response = await fetch(
    `https://api.bsn.cloud/2020/10/REST/Devices/${deviceId}/ScreenShots/`,
    {
      headers: { 'Authorization': `Bearer ${accessToken}` }
    }
  );

  const screenshots = await response.json();
  // Returns array of screenshot entities with URLs
  return screenshots;
}

Log Collection#

Retrieve device logs for troubleshooting:

System Logs: OS-level logs
Application Logs: BrightSign software logs
Error Logs: Captured errors and exceptions
Network Logs: Network activity logs

Access via Remote DWS (Diagnostic Web Server) API.

Network APIs#

REST API Overview#

BSN.cloud provides comprehensive REST APIs:

Base URLs:

Main API: https://api.bsn.cloud/2020/10/REST/
B-Deploy API: https://api.bdeploy.bsn.cloud/
Remote DWS: Dynamically assigned per device

API Versions:

2020/10: Stable, widely supported
2022/06: Enhanced features, recommended for new integrations

Authentication#

BSN.cloud uses OAuth2 for authentication:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
// Obtain access token
async function getAccessToken(clientId, clientSecret) {
  const response = await fetch('https://auth.bsn.cloud/api/v1/oauth2/token', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded'
    },
    body: new URLSearchParams({
      grant_type: 'client_credentials',
      client_id: clientId,
      client_secret: clientSecret,
      scope: 'bsn.api.main.*'  // Request appropriate scopes
    })
  });

  const data = await response.json();
  // Returns: { access_token, token_type: 'Bearer', expires_in, scope }
  return data.access_token;
}

Token Scopes:

bsn.api.main.devices.*: Device management
bsn.api.main.content.*: Content operations
bsn.api.main.presentations.*: Presentation management
bsn.api.main.operations.*: Business operations

Device Control#

Control devices via API:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
// Reboot a device
async function rebootDevice(serial, accessToken) {
  // Use Remote DWS WebSocket connection
  const ws = new WebSocket(`wss://dws.bsn.cloud/device/${serial}`);

  ws.onopen = () => {
    ws.send(JSON.stringify({
      method: 'POST',
      path: '/Reboot',
      auth: accessToken
    }));
  };

  ws.onmessage = (event) => {
    const response = JSON.parse(event.data);
    console.log('Reboot initiated:', response);
    ws.close();
  };
}

Content Operations#

Manage content programmatically:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// List all content with filtering
async function listContent(filter, accessToken) {
  const params = new URLSearchParams();
  if (filter) params.append('filter', filter);

  const response = await fetch(
    `https://api.bsn.cloud/2020/10/REST/Content/?${params}`,
    {
      headers: { 'Authorization': `Bearer ${accessToken}` }
    }
  );

  const result = await response.json();
  // Returns paged list with: items[], marker, isTruncated
  return result;
}

// Delete content
async function deleteContent(contentId, accessToken) {
  const response = await fetch(
    `https://api.bsn.cloud/2020/10/REST/Content/${contentId}/`,
    {
      method: 'DELETE',
      headers: { 'Authorization': `Bearer ${accessToken}` }
    }
  );

  return response.status === 204; // Success returns 204 No Content
}

Webhook Integration#

BSN.cloud can send webhooks for events:

Device Events: Online/offline, errors
Content Events: Upload complete, sync status
Presentation Events: Deployment status
System Events: Network changes, user actions

Configure webhooks in account settings or via API.

Live Content#

Live Data Feeds#

Integrate real-time data into presentations:

Live Text Feeds:

1
2
3
4
5
6
7
8
// Create live text feed
const textFeed = {
  name: 'Stock Ticker',
  url: 'https://api.example.com/stock-prices',
  refreshInterval: 60,  // seconds
  format: 'json',
  dataPath: '$.stocks[0].price'
};

Live Media Feeds:

1
2
3
4
5
6
7
// Create live media feed
const mediaFeed = {
  name: 'Promotional Videos',
  url: 'https://api.example.com/latest-videos',
  refreshInterval: 300,
  format: 'mrss'  // Media RSS
};

Dynamic Playlists#

Create playlists that update automatically:

Tag-based Playlists: Include content with specific tags
RSS/MRSS Feeds: Import content from external feeds
Data-driven Playlists: Content selection based on data sources

1
2
3
4
5
6
7
// Create dynamic playlist based on tags
const dynamicPlaylist = {
  type: 'tagged',
  filter: 'Category eq "Seasonal" and Season eq "Winter"',
  sortOrder: 'uploadDate DESC',
  maxItems: 10
};

Real-time Updates#

Push updates to players:

Instant Sync: Trigger immediate content synchronization
Emergency Messages: Override current playback
Live Overlays: Update ticker text, prices, or alerts

WebSocket Connections#

Maintain persistent connections for real-time control:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// Establish WebSocket connection to device
class DeviceConnection {
  constructor(serial, accessToken) {
    this.ws = new WebSocket(`wss://dws.bsn.cloud/device/${serial}`);
    this.token = accessToken;

    this.ws.onopen = () => {
      console.log('Connected to device:', serial);
    };

    this.ws.onmessage = (event) => {
      const message = JSON.parse(event.data);
      this.handleMessage(message);
    };
  }

  sendCommand(method, path, body = null) {
    this.ws.send(JSON.stringify({
      method,
      path,
      auth: this.token,
      body
    }));
  }

  handleMessage(message) {
    console.log('Received:', message);
  }
}

Server-Sent Events#

Alternative to WebSockets for one-way updates:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
// Listen for device events
const eventSource = new EventSource(
  `https://api.bsn.cloud/events/devices/${deviceId}`,
  {
    headers: { 'Authorization': `Bearer ${accessToken}` }
  }
);

eventSource.addEventListener('status', (event) => {
  const status = JSON.parse(event.data);
  console.log('Device status update:', status);
});

Analytics & Reporting#

Playback Reports#

Track content playback:

Play Count: Number of times content played
Play Duration: Total playback time
Completion Rate: Percentage of viewers who watched completely
Device Breakdown: Playback by device/location

Device Analytics#

Monitor device performance:

Uptime: Device availability percentage
Network Usage: Bandwidth consumption
Storage Usage: Storage capacity trends
Error Rates: Frequency of errors by type

Content Performance#

Analyze content effectiveness:

Popular Content: Most-played media
Engagement Metrics: Interaction rates (for touch displays)
Geographic Performance: Content performance by region
Time-based Analysis: Performance by time of day/week

Custom Events#

Log custom events for business intelligence:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
// Log custom event from player
// In BrightScript on player:
function LogCustomEvent(eventName as String, data as Object)
  beacon = CreateObject("roBeacon", "https://analytics.bsn.cloud/events")
  beacon.PostEvent(eventName, data)
end function

// Example usage
LogCustomEvent("ProductViewed", {
  productId: "12345",
  category: "Electronics",
  timestamp: CreateObject("roDateTime").ToISOString()
})

Data Export#

Export analytics data:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
// Export device analytics
async function exportAnalytics(startDate, endDate, accessToken) {
  const params = new URLSearchParams({
    startDate: startDate.toISOString(),
    endDate: endDate.toISOString(),
    format: 'csv'
  });

  const response = await fetch(
    `https://api.bsn.cloud/analytics/export?${params}`,
    {
      headers: { 'Authorization': `Bearer ${accessToken}` }
    }
  );

  return await response.blob();
}

Advanced Features#

Tagging and Filtering#

Organize devices and content with tags:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
// Add tags to device
async function tagDevice(deviceId, tags, accessToken) {
  const response = await fetch(
    `https://api.bsn.cloud/2020/10/REST/Devices/${deviceId}/Tags/`,
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(tags)
    }
  );

  return response.status === 204;
}

// Filter devices by tags
const filter = `Tags.Location eq "Store-01" and Tags.Department eq "Electronics"`;
const devices = await listDevices(filter, accessToken);

Device Groups#

Create logical device groups:

Geographic Groups: Group by location
Functional Groups: Group by purpose
Tagged Groups: Dynamic groups based on tags
Regular Groups: Static device collections

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
// Create device group
async function createGroup(groupData, accessToken) {
  const response = await fetch(
    'https://api.bsn.cloud/2020/10/REST/Groups/Regular/',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(groupData)
    }
  );

  return await response.json();
}

Role-Based Access#

Define granular permissions:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
// Create custom role
const customRole = {
  name: 'Content Manager',
  permissions: [
    { operation: 'content.create', allow: true },
    { operation: 'content.update', allow: true },
    { operation: 'content.delete', allow: true },
    { operation: 'devices.update', allow: false },
    { operation: 'devices.delete', allow: false }
  ]
};

Custom Plugins#

Extend player functionality with plugins:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// Upload and assign autorun plugin
async function deployPlugin(pluginFile, deviceIds, accessToken) {
  // 1. Upload plugin
  const formData = new FormData();
  formData.append('file', pluginFile);

  const uploadResponse = await fetch(
    'https://api.bsn.cloud/2020/10/REST/Autoruns/Plugins/',
    {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${accessToken}` },
      body: formData
    }
  );

  const plugin = await uploadResponse.json();

  // 2. Assign to devices
  for (const deviceId of deviceIds) {
    await fetch(
      `https://api.bsn.cloud/2020/10/REST/Devices/${deviceId}/`,
      {
        method: 'PATCH',
        headers: {
          'Authorization': `Bearer ${accessToken}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify([
          {
            op: 'replace',
            path: '/autorunPlugin',
            value: plugin.id
          }
        ])
      }
    );
  }
}

Third-Party Integrations#

BSN.cloud integrates with external systems:

CMS Integration: Connect to external content management systems
Analytics Platforms: Export data to Google Analytics, Adobe Analytics
Notification Services: Trigger alerts via Slack, Teams, PagerDuty
Data Sources: Import data from APIs, databases, RSS feeds

Security & Compliance#

Secure Communications#

All BSN.cloud communications are encrypted:

TLS 1.2+: All HTTPS/WebSocket connections
Certificate Validation: Verify server certificates
Token-based Auth: OAuth2 access tokens
API Rate Limiting: Prevent abuse

Certificate Management#

Manage security certificates:

Automatic Rotation: Certificates rotated automatically
Custom Certificates: Upload custom CA certificates if needed
Certificate Pinning: Optional for enhanced security

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
// Upload custom CA certificate (if required)
async function uploadCertificate(certFile, accessToken) {
  const formData = new FormData();
  formData.append('certificate', certFile);

  const response = await fetch(
    'https://api.bsn.cloud/certificates',
    {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${accessToken}` },
      body: formData
    }
  );

  return await response.json();
}

Access Control#

Implement least-privilege access:

User Roles: Assign minimum required permissions
API Scopes: Request only necessary scopes
IP Whitelisting: Restrict API access to known IPs
Token Expiration: Tokens expire after specified duration

Audit Logging#

Track all system activities:

User Actions: Login, content changes, device modifications
API Calls: All API requests logged
Device Events: Device status changes, errors
System Events: Configuration changes

Access audit logs via API or web interface.

BSN.cloud supports GDPR requirements:

Data Minimization: Collect only necessary data
Right to Access: Users can export their data
Right to Deletion: Data deletion on request
Data Retention: Configurable retention policies
Privacy Controls: Granular privacy settings

Troubleshooting#

Common Issues#

Player Not Connecting:

Verify network connectivity
Check firewall rules (ports 80, 443, WebSocket)
Confirm player is registered in BSN.cloud
Check device activation status

Content Not Downloading:

Verify storage space on player
Check content permissions
Confirm presentation assignment
Review download logs

API Authentication Failures:

Verify client credentials
Check token expiration
Confirm required scopes
Review API rate limits

Network Diagnostics#

Required network access:

Outbound HTTPS (443):
- api.bsn.cloud
- auth.bsn.cloud
- cdn.bsn.cloud
- dws.bsn.cloud

Outbound WebSocket (443):
- dws.bsn.cloud

Protocols:
- HTTPS/TLS 1.2+
- WebSocket (WSS)
- DNS resolution

Test connectivity from player:

' Test BSN.cloud connectivity
function TestBSNConnectivity() as Boolean
  urlTransfer = CreateObject("roUrlTransfer")
  urlTransfer.SetUrl("https://api.bsn.cloud/health")

  response = urlTransfer.GetToString()
  if response <> "" then
    print "BSN.cloud connectivity: OK"
    return true
  else
    print "BSN.cloud connectivity: FAILED"
    return false
  end if
end function

Sync Problems#

Troubleshoot synchronization issues:

Check Device Status: Verify device is online
Review Error Logs: Check for download failures
Verify Content Hashes: Ensure content integrity
Force Sync: Trigger manual synchronization
Clear Cache: Reset local content cache if corrupted

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
// Force device sync
async function forceSyncDevice(deviceId, accessToken) {
  const ws = new WebSocket(`wss://dws.bsn.cloud/device/${deviceId}`);

  ws.onopen = () => {
    ws.send(JSON.stringify({
      method: 'POST',
      path: '/SynchronizeNow',
      auth: accessToken
    }));
  };
}

Performance Optimization#

Optimize BSN.cloud integration:

Content Optimization:

Compress images and videos
Use appropriate resolution for display
Leverage progressive download for large files
Cache frequently accessed content

API Optimization:

Implement caching for API responses
Use batch operations when possible
Paginate large result sets
Implement retry logic with exponential backoff

Network Optimization:

Schedule large downloads during off-peak hours
Use content versioning to minimize transfers
Implement bandwidth throttling
Monitor network usage

Support Resources#

Get help with BSN.cloud:

Documentation: https://docs.brightsign.biz
API Reference: https://docs.brightsign.biz/display/DOC/BSN.cloud+APIs
Support Portal: https://support.brightsign.biz
Community Forum: https://forums.brightsign.biz
Email Support: support@brightsign.biz
Phone Support: Available for paid tiers

Required Resources#

To work with BSN.cloud integration, you need:

Accounts and Credentials:

BSN.cloud account (free or paid)
API client credentials (from BrightSign support)
Network ID (from BSN.cloud dashboard)

Hardware:

BrightSign player(s) with network connectivity
Network infrastructure (router, internet connection)
Display(s) connected to players

Software:

BrightAuthor:connected (for presentation authoring)
Web browser (for BSN.cloud web interface)
Development tools (for API integration)

Network Requirements:

Outbound internet access (HTTPS, WebSocket)
Adequate bandwidth for content delivery
Firewall configuration for BSN.cloud endpoints

Best Practices#

Network Security Configuration#

Firewall Rules:

# Allow outbound HTTPS
Allow TCP port 443 to api.bsn.cloud
Allow TCP port 443 to auth.bsn.cloud
Allow TCP port 443 to cdn.bsn.cloud
Allow TCP port 443 to dws.bsn.cloud

# Allow DNS
Allow UDP port 53

# Block all other outbound traffic (optional)

Network Segmentation:

Isolate digital signage network from corporate network
Use VLANs to separate traffic
Implement network monitoring

Content Optimization for Cloud Delivery#

Video Encoding:

Recommended settings:
- Container: MP4
- Video codec: H.264 (Main or High profile)
- Audio codec: AAC
- Bitrate: Match display resolution (e.g., 10 Mbps for 1080p)
- Keyframe interval: 2 seconds

Image Optimization:

Use JPEG for photos (80-90% quality)
Use PNG for graphics with transparency
Resize to native display resolution
Optimize file size with tools like ImageOptim

File Organization:

Use descriptive filenames
Organize into logical folders
Apply consistent tagging
Document content purpose and usage

Backup and Recovery Strategies#

Content Backup:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
// Automated content backup
async function backupContent(accessToken) {
  const content = await listAllContent(accessToken);

  for (const item of content) {
    const fileResponse = await fetch(item.downloadUrl);
    const blob = await fileResponse.blob();

    // Save to local backup storage
    await saveToBackup(`backup/${item.path}`, blob);
  }
}

Configuration Backup:

Export device configurations regularly
Backup presentation definitions
Save network settings
Document custom integrations

Disaster Recovery:

Maintain offline content copies
Document recovery procedures
Test recovery process periodically
Keep emergency contact list

Monitoring and Alerting Setup#

Health Monitoring:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
// Monitor device health
async function monitorDevices(accessToken) {
  const devices = await listAllDevices(accessToken);

  for (const device of devices) {
    const status = await getDeviceStatus(device.id, accessToken);

    // Check critical metrics
    if (status.storageAvailable < 1073741824) { // < 1GB
      sendAlert(`Low storage on ${device.name}`);
    }

    if (Date.now() - status.lastCheckIn > 900000) { // > 15 min
      sendAlert(`Device offline: ${device.name}`);
    }
  }
}

// Run every 5 minutes
setInterval(() => monitorDevices(token), 300000);

Alert Channels:

Email notifications
SMS for critical alerts
Webhook to monitoring platforms
Dashboard for real-time status

Scalability Planning#

Network Growth:

Plan for 20-30% annual growth
Monitor API rate limits
Consider enterprise tier for large deployments
Implement efficient querying and filtering

Content Management:

Establish content approval workflows
Implement content lifecycle policies
Archive obsolete content
Monitor storage usage trends

Performance Considerations:

Cache API responses
Batch operations when possible
Implement pagination for large datasets
Use webhooks instead of polling

Cost Management:

Monitor bandwidth usage
Optimize content sizes
Review subscription tier regularly
Archive unused content

Summary#

BSN.cloud provides a comprehensive cloud platform for managing BrightSign digital signage networks. Key capabilities include:

Centralized Management: Control all devices from a single interface
Automated Provisioning: Streamline device deployment with B-Deploy
Content Distribution: Efficient CDN-based content delivery
Remote Control: Manage devices from anywhere via APIs
Live Content: Integrate real-time data and dynamic content
Analytics: Track performance and engagement
Security: Enterprise-grade security and compliance
Scalability: Supports networks from single displays to thousands

By leveraging BSN.cloud APIs and following best practices, you can build scalable, secure, and efficient digital signage solutions that meet enterprise requirements.

For the latest API documentation and updates, visit: https://docs.brightsign.biz/display/DOC/BSN.cloud+APIs