Step 1–2: Create your server and get API credentials

This section covers two actions: (1) create your Shoutcast Net server, and (2) collect the exact connection details your custom app will use. Even if you’re already streaming, it’s worth organizing these values into a single config object so your API integration stays consistent.

Step 1: Spin up your Shoutcast Net service

Choose a plan that matches your stream type (music radio, talk/podcast live, church service, school radio, or live events). Shoutcast Net plans start at $4/month and include the benefits broadcasters care about: 99.9% uptime, SSL streaming, and unlimited listeners—without surprise overage fees.

• • Start here: Shoutcast hosting
• • If you need 24/7 automation: AutoDJ
• • If you’re comparing alternatives: Icecast hosting
• • Ready to deploy immediately: Shop plans

Step 2: Collect the values your API client needs

In your station control panel, locate the server details your app will reference. At minimum, record:

• • Host (e.g., yourstation.shoutcastnet.com)
• • Port (stream port and, if applicable, an admin/API port)
• • Stream identifier (stream ID, mount, or endpoint depending on your setup)
• • Credentials (API token/password/keys as provided in your panel)
• • SSL URL (https endpoint for your API calls and secure player links)

Recommended configuration format

Store your integration settings as environment variables (preferred) and map them into a single config object in your application:

// Example: Node.js config (do not commit real secrets)
export const shoutcastNet = {
  baseUrl: process.env.SCNET_BASE_URL,      // e.g., https://yourpanel-or-api-host
  stationId: process.env.SCNET_STATION_ID,  // if your plan uses station identifiers
  apiToken: process.env.SCNET_API_TOKEN,    // token/secret from your control panel
  streamHost: process.env.SCNET_STREAM_HOST,
  streamPort: Number(process.env.SCNET_STREAM_PORT || 0),
  useSsl: process.env.SCNET_USE_SSL === "true",
};

This makes it easy to deploy the same code to multiple stations (for example, a school district with several campuses) by swapping environment variables.

Step 4–6: Read Now Playing, listeners, and stream status

Now we’ll implement the most common use cases for DJs and broadcasters: displaying Now Playing, showing listener totals, and detecting whether the stream is online. These features power everything from website widgets to in-studio dashboards to “Now Playing” overlays in OBS.

Step 4: Read “Now Playing” for your website/app

Your goal: return a simple JSON payload your frontend can display—track title, artist, and timestamp. Exact endpoint paths vary by service configuration, so check your Shoutcast Net panel/API docs for the canonical routes. Your implementation pattern is consistent:

• • Call the API “now playing” endpoint on the server side
• • Normalize the response to your app’s schema
• • Cache for 3–10 seconds (metadata doesn’t need millisecond updates)

// Example: your app endpoint handler (pseudo-code)
export async function getNowPlaying() {
  const data = await scnetRequest(`/v1/stations/${process.env.SCNET_STATION_ID}/now-playing`);
  return {
    title: data?.track?.title ?? "",
    artist: data?.track?.artist ?? "",
    startedAt: data?.track?.startedAt ?? null,
    artworkUrl: data?.track?.artworkUrl ?? null,
  };
}

Step 5: Read listeners (current, peak, uniques)

Listener stats are useful for:

• • DJ dashboards (motivation + timing)
• • Sponsor reports
• • Church attendance analytics for online services
• • School stations proving engagement to administrators

// Example: listener stats request (pseudo-code)
export async function getListenerStats() {
  const data = await scnetRequest(`/v1/stations/${process.env.SCNET_STATION_ID}/listeners`);
  return {
    current: data?.current ?? 0,
    peak: data?.peak ?? 0,
    unique: data?.unique ?? 0,
  };
}

Step 6: Monitor stream status (online/offline, bitrate, health)

A stream status endpoint is the backbone of alerting and automation. For example, if your live encoder crashes during a concert, you can automatically fail over to AutoDJ or display a message in your app.

// Example: stream status request (pseudo-code)
export async function getStreamStatus() {
  const data = await scnetRequest(`/v1/stations/${process.env.SCNET_STATION_ID}/status`);
  return {
    online: Boolean(data?.online),
    bitrateKbps: data?.bitrateKbps ?? null,
    codec: data?.codec ?? null,
    listeners: data?.listeners ?? 0,
  };
}

Comparison: Shoutcast Net flat-rate vs Wowza variable billing

If your custom app makes listening easier, your audience grows—and billing models matter. Here’s why many broadcasters prefer Shoutcast Net for predictable costs:

Step 9–10: Automate with AutoDJ, scheduling, and alerts

The biggest payoff from an API integration is automation: scheduled programming, automatic fallbacks, and proactive alerts when something breaks. This is where Shoutcast Net is especially broadcaster-friendly—without forcing you into Wowza’s expensive per-hour/per-viewer billing for routine station operations.

Step 9: Schedule programming with AutoDJ

If your station runs 24/7, AutoDJ can handle playlists, rotations, and scheduled shows. Your custom app can become a “program director” interface: upload content, schedule blocks, and display what’s queued next.

A practical scheduling pattern:

• • Maintain a schedule in your app (show name, start/end, playlist ID)
• • Sync changes to Shoutcast Net via the API (create/update schedule entries)
• • Use Now Playing + queue endpoints to show “Up Next”
• • Add a manual override button for staff (switch to live source)

// Example: create schedule entry (pseudo-code)
export async function createScheduleEntry(entry) {
  // entry: { name, startTime, endTime, playlistId, timezone }
  const data = await scnetRequest(`/v1/stations/${process.env.SCNET_STATION_ID}/autodj/schedule`, {
    method: "POST",
    body: entry,
  });
  return { ok: true, result: data };
}

Step 10: Add alerts (downtime, silence, metadata stuck)

Build alerts around the stream status checks you created earlier. Common broadcaster alerts include:

• • Stream goes offline (encoder crash, network issue)
• • Listener count drops suddenly (possible outage)
• • Metadata hasn’t changed for X minutes (automation stuck)
• • Bitrate/codec mismatch (misconfigured encoder preset)

A simple approach is a cron job (or serverless scheduler) that polls status every 30–60 seconds and notifies via email/SMS/Discord when thresholds are crossed:

// Example: alert loop (pseudo-code)
export async function healthCheckAndAlert(notify) {
  const status = await getStreamStatus();

  if (!status.online) {
    await notify("Stream offline: switching to AutoDJ or investigating encoder.");
    // Optional: trigger a failover action
    // await switchToAutoDj();
  }

  if (status.bitrateKbps !== null && status.bitrateKbps < 64) {
    await notify(`Low bitrate detected (${status.bitrateKbps} kbps). Check encoder settings.`);
  }
}

Why this automation matters for churches, schools, and events

Volunteer teams rotate. Student staff changes every semester. Live events have unpredictable connectivity. Automation plus clear alerts means your stream stays reliable—supporting 99.9% uptime goals and keeping your audience engaged whether they listen on mobile, desktop, smart speakers, or embedded players.

And because Shoutcast Net is designed for unlimited listeners on a predictable plan, you can promote your stream without worrying about audience spikes turning into a billing emergency (a common fear under Wowza’s expensive per-hour/per-viewer billing).

Next steps: launch, test, and scale

• • Test with real devices and networks (Wi-Fi + cellular)
• • Verify SSL URLs in all players
• • Confirm your app can stream from any device to any device in your target environments
• • Document your failover plan (live encoder → AutoDJ)
• • If you’re ready, pick a plan from the shop or start a 7 days trial