Get your data from anywhere.
From your first test sensor to an established commercial fleet. Plan, connect, and access your data with self-service tools. Connected with Iridium satellites.
Built by Pacific Gyre. Decades of satellite-connected device experience.
Start where you are.
New to satellite or already deploying fleets. Start at any step.
Choose one from each. No signup. Selections stay on this page.
Your suggested next step
Start with what you want to achieve.
No satellite or coding experience needed to explore your options.
Focus on your research. We help with the connection.
The field. Now on your screen.
Explore a sample five-device dashboard. Your readings, locations, and downloads in one place.
Your telemetry station
Welcome, Operator
Live device locations
Ending balance
409.31
Top-up needed
None
Coastal Drifter
300234010000001 · SBD
activeactive- +4 more devices
- 300234010000001+4 more
One platform. Your way forward.
Use the tools you need. Bring what you have. Get help where it counts.
Know your cost before you pay.
An Iridium modem is the small satellite radio inside your device. It sends your readings to Iridium satellites from anywhere on Earth, with no cell coverage needed.
- Recommended
Iridium Certus 9704
For new projects
- Up to 100 KB per message
- More affordable data
- Existing devices
Iridium SBD 9602 / 9603
For devices with SBD built in
- Up to 340 bytes per message
- Keep hardware you already own
The BEAR Module.
Less to piece together. More time to measure.
A host-independent Iridium carrier in development. Open-source host SDK, power management design, and optional GNSS integration. Built around the Telemetry Station workflow.
Iridium 9704 modem
In development · April 2027, tentative
Availability
The BEAR Module is not a shipping product today. Final specifications and availability are subject to validation. Eligible existing Iridium modems can use Telemetry Station now. The board shown is illustrative, not to scale.
Small message. More possibilities.
Choose your readings. We pack the message and generate the code.
Your readings
- Temperature
- 18.5 °C
- Battery %
- 84%
- Latitude
- 32.87051
- Longitude
- -117.24103
Sample readings. Private to your browser.
Ready to send
9 bytesvs. 76 bytes as JSON
Hex: 4935176f8962fe19c8
Less data to send. Code generated for you.
See airtime costsInspect the generated C code
Review and test this encoder with a matching decoder. It is not complete device firmware.
/*
* Telemetry Station Payload Optimizer Tool
* https://telemetrystation.com/payload-optimizer
*
* Target: Iridium SBD (340 byte maximum)
* Fields are packed from most-significant bit to least-significant bit
* in the exact order shown below. The final byte is zero-padded.
*
* Maximum layout:
* 01. temperature: 11 max bits; max offset 0
* 02. battery: 7 max bits; max offset 11
* 03. latitude: 25 max bits; max offset 18
* 04. longitude: 26 max bits; max offset 43
*
* Build: cc -std=c11 -Wall -Wextra -pedantic payload.c -lm -o payload
*/
#include <stdbool.h>
#include <stdint.h>
#include <inttypes.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#define MAX_PAYLOAD_BYTES 340u
bool write_bits(
uint8_t *output,
size_t capacity_bytes,
size_t *bit_position,
uint64_t value,
size_t bit_count
) {
if (bit_count > 64u || *bit_position + bit_count > capacity_bytes * 8u) {
return false;
}
for (size_t offset = 0; offset < bit_count; ++offset) {
const size_t shift = bit_count - 1u - offset;
const size_t byte_index = *bit_position / 8u;
const size_t bit_index = 7u - (*bit_position % 8u);
const uint8_t bit = (uint8_t)((value >> shift) & UINT64_C(1));
output[byte_index] |= (uint8_t)(bit << bit_index);
*bit_position += 1u;
}
return true;
}
bool write_unsigned(
uint8_t *output,
size_t capacity_bytes,
size_t *bit_position,
uint64_t value,
size_t bit_count
) {
if (bit_count == 0u || bit_count > 64u) return false;
if (bit_count < 64u && value > ((UINT64_C(1) << bit_count) - UINT64_C(1))) {
return false;
}
return write_bits(output, capacity_bytes, bit_position, value, bit_count);
}
bool write_signed(
uint8_t *output,
size_t capacity_bytes,
size_t *bit_position,
int64_t value,
size_t bit_count
) {
if (bit_count < 2u || bit_count > 64u) return false;
if (bit_count < 64u) {
const int64_t minimum = -(INT64_C(1) << (bit_count - 1u));
const int64_t maximum = (INT64_C(1) << (bit_count - 1u)) - INT64_C(1);
if (value < minimum || value > maximum) return false;
}
const uint64_t encoded = (uint64_t)value;
const uint64_t masked =
bit_count == 64u ? encoded : encoded & ((UINT64_C(1) << bit_count) - UINT64_C(1));
return write_bits(output, capacity_bytes, bit_position, masked, bit_count);
}
uint64_t power_of_ten(size_t decimal_places) {
uint64_t result = UINT64_C(1);
for (size_t index = 0; index < decimal_places; ++index) result *= UINT64_C(10);
return result;
}
bool write_scaled_float(
uint8_t *output,
size_t capacity_bytes,
size_t *bit_position,
double value,
double minimum,
double maximum,
size_t decimal_places,
size_t bit_count
) {
if (!isfinite(value) || value < minimum || value > maximum) return false;
const uint64_t scale = power_of_ten(decimal_places);
const uint64_t scaled = (uint64_t)llround((value - minimum) * (double)scale);
return write_bits(output, capacity_bytes, bit_position, scaled, bit_count);
}
bool write_sized_bytes(
uint8_t *output,
size_t capacity_bytes,
size_t *bit_position,
const uint8_t *value,
size_t value_length,
size_t maximum_bytes,
size_t length_bits
) {
if (value_length > maximum_bytes) return false;
if (!write_bits(output, capacity_bytes, bit_position, (uint64_t)value_length, length_bits)) {
return false;
}
for (size_t index = 0; index < value_length; ++index) {
if (!write_bits(output, capacity_bytes, bit_position, value[index], 8u)) return false;
}
return true;
}
bool write_sized_ascii(
uint8_t *output,
size_t capacity_bytes,
size_t *bit_position,
const char *value,
size_t maximum_bytes,
size_t length_bits
) {
const size_t value_length = strlen(value);
for (size_t index = 0; index < value_length; ++index) {
if ((unsigned char)value[index] > 0x7fu) return false;
}
return write_sized_bytes(
output, capacity_bytes, bit_position, (const uint8_t *)value,
value_length, maximum_bytes, length_bits
);
}
int main(void) {
/* Edit these example sensor values. */
const double temperature = 18.5;
const uint64_t battery = UINT64_C(84);
const double latitude = 32.87051;
const double longitude = -117.24103;
uint8_t payload[MAX_PAYLOAD_BYTES] = {0};
size_t bit_position = 0u;
if (!write_scaled_float(payload, sizeof(payload), &bit_position, temperature, -40.0, 85.0, 1u, 11u)) {
fputs("Could not encode Temperature.\n", stderr);
return 1;
}
if (!write_unsigned(payload, sizeof(payload), &bit_position, battery, 7u)) {
fputs("Could not encode Battery %.\n", stderr);
return 1;
}
if (!write_scaled_float(payload, sizeof(payload), &bit_position, latitude, -90.0, 90.0, 5u, 25u)) {
fputs("Could not encode Latitude.\n", stderr);
return 1;
}
if (!write_scaled_float(payload, sizeof(payload), &bit_position, longitude, -180.0, 180.0, 5u, 26u)) {
fputs("Could not encode Longitude.\n", stderr);
return 1;
}
const size_t payload_bytes = (bit_position + 7u) / 8u;
for (size_t index = 0; index < payload_bytes; ++index) {
printf("%02x", payload[index]);
}
printf("\n%zu bits / %zu bytes\n", bit_position, payload_bytes);
return 0;
}
About this example
Same sample readings, compared with JSON. Actual charges depend on plan minimums, reporting frequency, and device count. Byte savings are not a price quote.
Your hardware. Your workflow.
Bring your Iridium modem. Send data where you already work. Fleets, migrations, and custom integrations get our team.
Your hardware
- Certus 9704
- SBD 9602 / 9603
Telemetry Station
Your workflow
- Dashboard
- API
- HTTPS
- DirectIP
Questions, answered.
Can you help with an existing fleet or product?
Yes. Bring your existing design and requirements. Our team can review eligible Iridium device activation, fleet migration, data integration, and custom hardware or firmware work. Compatibility and project scope need review; you do not have to replace your workflow with ours.
New to satellite. Can you help me get started?
Yes. Tell us what you need to measure, where your instrument will be, and how often you need readings. Our team can help you plan the hardware, connection, and data workflow. Or use the self-service tools at your own pace.
What is an Iridium modem, and which one should I choose?
An Iridium modem is the small satellite radio inside your device that sends readings through Iridium satellites from anywhere on Earth, with no cell coverage needed. For a new project, we recommend Iridium Certus 9704: it carries messages up to 100 KB and its data is more affordable. Iridium SBD 9602 / 9603 modems carry messages up to 340 bytes and are best when your device already has one built in.
Can I use the instrument I already have?
Possibly. Telemetry Station supports eligible Iridium Certus 9704 and SBD 9602 / 9603 modems. Your instrument also needs compatible hardware and firmware. Tell us what you have, and we can review the integration before you commit.
How do I know what it will cost?
Use our free calculators before you commit. Cost depends on how many devices you connect, how much data they send, and how often. If you do not know those details yet, our team can help you work them out.
Real-world projects
Can I get data from a buoy, drifter, or mooring in the open ocean?
Yes. Iridium satellites cover every ocean, so a buoy, drifter, or mooring can send readings such as position, water temperature, or wave data from far offshore. Pacific Gyre, the team behind Telemetry Station, has designed ocean drifters and trackers for research programs for decades.
How can I monitor a river, lake, or reservoir with no cell service?
Connect your water level, flow, or water quality logger to an Iridium modem. It sends readings by satellite on the schedule you set, and you see them in the dashboard, so you know about a flood or a dry spell without driving out to the gauge.
Does satellite telemetry work in the Arctic, Antarctica, or on a glacier?
Yes. Iridium covers the whole planet, including both poles, where most other networks do not reach. Researchers use it for ice motion, snow depth, permafrost temperature, and polar weather. Cold, dark winters make power planning important, and our team can help.
Can I send readings from a mountain weather station or wildfire-risk site?
Yes. Weather and fire-weather stations on ridges, in canyons, and in back country often have no cell coverage. A satellite modem can send temperature, humidity, wind, rainfall, and battery status several times an hour or once a day, as your project needs.
Can I use Telemetry Station for wildlife or animal tracking?
Possibly. Collars and tags with an eligible Iridium 9602, 9603, or 9704 modem can send positions and activity data from anywhere. Tags are small and battery limited, so tell us about your species and study before you commit, and we can review it with you.
Can farms and ranches monitor tanks, wells, or soil beyond cell coverage?
Yes. Water tank levels, well pumps, soil moisture, and gate or fence sensors on remote land can report by satellite, saving long drives just to check a reading. Small messages a few times a day keep both airtime and power use low.
Can companies monitor pipelines, wellheads, or other remote infrastructure?
Yes. Pressure, flow, level, temperature, and equipment status from remote sites can be sent by satellite and delivered to the dashboard, the API, or your own systems over HTTPS, DirectIP, or email. For larger fleets, talk to our team about integration.
Can I track a boat, autonomous vehicle, or research glider at sea?
Yes. A device with an eligible Iridium modem and GPS can report its position and sensor readings while it travels, and the dashboard shows device locations on a map. Choose how often it reports to balance tracking detail, power, and cost.
Planning a deployment
Is satellite telemetry too expensive for a small research project?
Often not. Many projects send a few small messages a day, which keeps airtime affordable. Use the free calculators to estimate your cost before you pay. Credits are prepaid at $1 = 1 credit, with no contract, so you can start with a single device.
Do I still need to visit my site to download data?
Not for data. Your device sends readings by satellite as it collects them, so you see them in the dashboard without a site visit. You may still visit for maintenance, such as batteries, cleaning, or calibration, but not just to download a logger.
What equipment do I need at the remote site?
Your sensor or data logger, an eligible Iridium modem with an antenna, a power source such as a battery or solar panel, and a weatherproof enclosure. If you are not sure where to start, our team can help you plan the hardware and the connection.
Does my antenna need a clear view of the sky?
Yes. Iridium works best with an open view of the sky. Dense tree cover, deep canyons, buildings, and water over the antenna can block messages. Ocean devices send when they are at the surface. Mount the antenna as high and open as you can.
How often can my device send data?
You choose. Some projects report every few minutes, others once a day. More frequent or larger messages give you more detail, but they use more airtime and battery. The calculators show how your reporting interval changes the cost.
What kind of data can I send by satellite?
Numbers and short records work best: temperatures, levels, positions, counts, battery voltage, alarms, and summary statistics. Iridium Certus 9704 carries up to 100 KB per message for longer records or batches of readings. Continuous video or raw high-rate audio is not practical.
How long can a satellite device run on batteries?
It depends on your sensors, how often you send, message size, and the climate. Sending fewer, smaller messages is the easiest way to save power, and the free Payload Optimizer packs readings into fewer bytes. Our team can help you estimate a power budget.
Can I test with one device before deploying a fleet?
Yes. Activate a single eligible device with prepaid credits and no contract, check your data end to end, then add more devices when you are ready. Each deployment has its own start and end dates.
Can I pause service between field seasons?
Yes. Deployments have start and end dates, and devices can be suspended or reactivated from the dashboard. Fees may apply, so check the pricing page and calculators for your plan.
Your data
How quickly does my data arrive?
Messages usually arrive within minutes of being sent, and you see them in the dashboard and API. Satellite visibility, antenna placement, and network conditions can cause delays, so delivery time is not guaranteed.
How do I get my data into Excel, R, Python, or MATLAB?
Download your messages as CSV or JSON from the dashboard, or pull them automatically with the Telemetry Station API. Both work with spreadsheets and analysis tools you already use.
Can my data go straight to my own server or database?
Yes. Set an HTTPS, DirectIP, or email destination during activation and each message is forwarded as it arrives. You can also call the API on a schedule to load data into your own database.
Can I see where my devices are on a map?
Yes. The dashboard shows each device's location on a map along with its latest readings, status, and credit balance, so you can check a whole fleet at a glance.
Can I send commands or change settings on my device remotely?
Iridium supports two-way messaging, so a device can receive commands such as a new reporting interval. Sending messages to devices from the Telemetry Station dashboard is coming soon. Contact us if your project needs it now.
How long is my data stored?
Up to five years from when it arrives, with no standard storage fee, while your account is active and in good standing, subject to the Terms.
About Telemetry Station
What is Telemetry Station?
Telemetry Station by Pacific Gyre gets data from remote sensors to the people who use it. Plan your message, price airtime before you pay, activate an eligible Iridium modem, and use your data in the dashboard or API. Do it yourself, or with our team.
How do I activate an Iridium modem?
Price your deployment in the calculator, verify your email and device IMEIs, fund your account through checkout, and send your first message. If you already know your details, it can take about 5 minutes, though timing is not guaranteed.
Do I need to buy hardware from you?
No. You can activate eligible Iridium Certus 9704 and SBD 9602 / 9603 modems bought from any supplier. If you need hardware help, our team can work with you, and we are developing the BEAR Module to make the hardware side simpler.
What is the BEAR Module, and why are you building it?
BEAR Module 9704 is a host-independent Iridium carrier Pacific Gyre is developing to simplify satellite-connected instruments. It is in G1 design, with an alpha host SDK and optional GNSS integration in progress. Pre-order inquiries take no payment; April 1, 2027 is a tentative sales target, subject to validation, approvals and production readiness.
Why does message size matter, and what does the Payload Optimizer do?
Satellite airtime cost depends on how much data you send, so smaller messages cost less and save battery. The free Payload Optimizer packs your sensor readings into fewer bytes and generates C code you can inspect and use in your device firmware.
How is Telemetry Station different from Ground Control or MetOcean?
Telemetry Station is built for the people who use the data, such as scientists, monitoring teams, and project leads, not only engineers. It offers transparent self-service pricing, prepaid credits, fast activation, and personal help when you want it. Ground Control and MetOcean are established providers with their own strengths. See our buyer guides for a factual comparison.
Do you offer consulting, integrations, or partnerships?
Yes. You can activate on your own, or work with us across firmware, sensors, satellite connectivity, and cloud data integration. We are also open to partnerships and integrations.
Do you offer a research program for students?
Yes. The Telemetry Station Summer Research Program pairs students with mentors to design a sensing experiment, write embedded C, send satellite messages with a loaned BEAR Module 9704, and analyze the results. See the research program page for dates and how to apply.
Service and technical details
Which Iridium modems are supported?
The standard self-service workflow is intended for eligible Iridium Certus 9704 and SBD 9602 / 9603 SBD modems. Eligibility depends on the modem's current service state, configuration, and the deployment. Telemetry Station does not claim compatibility with every Iridium device.
Is activation guaranteed in five minutes?
No. Telemetry Station is designed to move a straightforward eligible deployment from estimate to activation in about five minutes, but activation timing is not guaranteed. Iridium provisioning, payment, device eligibility, network availability, and other third-party or deployment conditions can affect timing.
How do prepaid credits work?
Unless otherwise stated, $1.00 equals 1.00 Telemetry Station credit. Credits pay eligible platform service charges; they are not cash deposits and are generally non-refundable except where required by law or approved in writing.
What happens if my account is inactive?
Under the current Terms, if an account remains inactive for 12 months, Telemetry Station may close it and expire or forfeit unused credits, subject to applicable law and the notice provisions in the Terms.
How long are telemetry messages retained?
Telemetry Station provides up to five years of message retention, with no standard storage fee, while the account remains active and in good standing, subject to the Terms, technical limits, and account status.
Can I configure custom destinations?
Yes. SBD and Certus devices can forward messages to Email, DirectIP, and HTTPS destinations. Destinations are set once in the deployment details when you activate devices and stay fixed until the devices are deactivated or the deployment end date passes.
Can I get a refund for unused credits?
Credit purchases are generally final and non-refundable except where required by law or expressly approved by Telemetry Station in writing. Review the Terms before purchasing.
What can affect satellite connectivity or message delivery?
Iridium service depends on third-party network availability, satellite visibility, antenna installation, modem configuration, environmental conditions, and other deployment factors outside Telemetry Station's control. Connectivity, latency, message delivery, and activation timing are not guaranteed.
What support is available?
Activate on your own, or work with us throughout your R&D process, from firmware to cloud data integration. We are open to partnerships and integrations, and can do much more than Iridium activation. Projects that need a defined support SLA should confirm it in writing.
What if I have 20+ devices, a migration, or a second-source requirement?
Contact us. Larger fleets, migrations, private data requirements, and custom hardware or software are all good reasons for a direct technical review.
What are you building next?
A first project, a new product, or an established fleet. Move forward on your own, or with our team.