Industrial IoT / SCADA · API / SDK

EdgeX Foundry

Connect edge device services through a modular platform.

Official documentation Download development spec

Technical references are pinned to EdgeX 4.0 documentation, not a claim that 4.0 is the newest release. Repository main is development code; select compatible released service and SDK versions.

EDGEX FOUNDRY / DEVELOPER FIELD GUIDE

Choose an interface. Define a verifiable result.

Company or project context, ten technical entry points and a practical analysis of every reference.

2026-10-08 · Integration not tested

Company / project overview

Original summary of official company or project statements; use the source for the full original page.

EdgeX Foundry · About
Project	EdgeX Foundry is a vendor-neutral open-source IoT edge framework hosted by the Linux Foundation.
Architecture	The project separates device integration, core services and application processing through interoperable components.
Repository role	edgex-go contains Go core/support service implementations; its main branch warns it is development work.

Complete official About page ↗

About reference — TA analysis
Audience	Buyers, partners and product owners shortlisting an AI provider.
Our assessment	Use positioning and company history for initial fit. Obtain project-specific deployment, support and commercial terms separately.

Official sources reviewed; no live API, inference or benchmark was run. Expected results are proposed internal contracts.

Top 10 technical entry points

Ten documented technical entry points selected by developer task; not ten separate SDKs or an official ranking.

Choose by the work you need to complete
Interface	Purpose and audience
01 · Core Command APIAPI / SDK / developer guide	Access device commands through a common service.Device integration teams
02 · Core Data APIAPI / SDK / developer guide	Access events and readings.Telemetry developers
03 · Core Metadata APIAPI / SDK / developer guide	Manage device and profile metadata.Device registry teams
04 · Core Keeper APIAPI / SDK / developer guide	Use the Core Keeper service interface.Platform operators
05 · Application Functions Go SDKAPI / SDK / developer guide	Build application pipelines that consume edge events.Go application developers
06 · Application Functions Python SDKAPI / SDK / developer guide	Build application functions using Python.Python edge teams
07 · Device Service Go SDKAPI / SDK / developer guide	Implement a device service for an external protocol.Go driver authors
08 · Device Service C SDKAPI / SDK / developer guide	Implement native device service integrations.C device integrators
09 · Device profilesAPI / SDK / developer guide	Describe resources, types and commands for a device.Device model designers
10 · Store and ForwardAPI / SDK / developer guide	Retain data for later delivery when exporting fails.Resilience engineers

Reference analysis

Capabilities summarize official documentation. Constraints and proposed tests are our engineering assessment.

API / SDK / developer guide

Core Command API

Core Command API · TA
Target audience	Device integration teams
Documented capability	Access device commands through a common service.
Input → output	Device command request → adapter/device response.
Execution environment	Compatible EdgeX 4.0 services, SDKs and configured device adapters
Our decision constraint	Accepted command does not establish the intended physical effect.
Our suggested validation	Confirm command result and actual device state separately.

Official reference · Core Command API ↗

API / SDK / developer guide

Core Data API

Core Data API · TA
Target audience	Telemetry developers
Documented capability	Access events and readings.
Input → output	Event/read query → stored telemetry.
Execution environment	Compatible EdgeX 4.0 services, SDKs and configured device adapters
Our decision constraint	Stored readings may be stale or use profile-specific types.
Our suggested validation	Validate timestamps, units and device identifiers.

Official reference · Core Data API ↗

API / SDK / developer guide

Core Metadata API

Core Metadata API · TA
Target audience	Device registry teams
Documented capability	Manage device and profile metadata.
Input → output	Device/profile definition → registered metadata.
Execution environment	Compatible EdgeX 4.0 services, SDKs and configured device adapters
Our decision constraint	Registration alone does not prove physical connectivity.
Our suggested validation	Check profile references and adapter configuration.

Official reference · Core Metadata API ↗

API / SDK / developer guide

Core Keeper API

Core Keeper API · TA
Target audience	Platform operators
Documented capability	Use the Core Keeper service interface.
Input → output	Supported configuration/registry request → service response.
Execution environment	Compatible EdgeX 4.0 services, SDKs and configured device adapters
Our decision constraint	Match the deployed service API instead of older registry assumptions.
Our suggested validation	Verify required service configuration and unavailable-backend behavior.

Official reference · Core Keeper API ↗

API / SDK / developer guide

Application Functions Go SDK

Application Functions Go SDK · TA
Target audience	Go application developers
Documented capability	Build application pipelines that consume edge events.
Input → output	Edge events → transformed/exported data.
Execution environment	Compatible EdgeX 4.0 services, SDKs and configured device adapters
Our decision constraint	Pipeline success and external destination persistence are separate.
Our suggested validation	Test filtering, transformation and destination failure.

Official reference · Application Functions Go SDK ↗

API / SDK / developer guide

Application Functions Python SDK

Application Functions Python SDK · TA
Target audience	Python edge teams
Documented capability	Build application functions using Python.
Input → output	Subscribed event → Python processing output.
Execution environment	Compatible EdgeX 4.0 services, SDKs and configured device adapters
Our decision constraint	Verify feature availability for the selected Python SDK release.
Our suggested validation	Replay the same event fixtures and verify exception propagation.

Official reference · Application Functions Python SDK ↗

API / SDK / developer guide

Device Service Go SDK

Device Service Go SDK · TA
Target audience	Go driver authors
Documented capability	Implement a device service for an external protocol.
Input → output	Protocol driver data → EdgeX events/readings.
Execution environment	Compatible EdgeX 4.0 services, SDKs and configured device adapters
Our decision constraint	Hardware and protocol handling remain the driver’s responsibility.
Our suggested validation	Check reconnect, type conversion and shutdown behavior.

Official reference · Device Service Go SDK ↗

API / SDK / developer guide

Device Service C SDK

Device Service C SDK · TA
Target audience	C device integrators
Documented capability	Implement native device service integrations.
Input → output	Native protocol data → framework readings.
Execution environment	Compatible EdgeX 4.0 services, SDKs and configured device adapters
Our decision constraint	Memory ownership and build dependencies require target validation.
Our suggested validation	Exercise malformed packets and cleanup on disconnect.

Official reference · Device Service C SDK ↗

API / SDK / developer guide

Device profiles

Device profiles · TA
Target audience	Device model designers
Documented capability	Describe resources, types and commands for a device.
Input → output	Profile definition → interpreted device resources.
Execution environment	Compatible EdgeX 4.0 services, SDKs and configured device adapters
Our decision constraint	Wrong scaling or units can produce plausible but incorrect readings.
Our suggested validation	Verify conversion against manufacturer reference values.

Official reference · Device profiles ↗

API / SDK / developer guide

Store and Forward

Store and Forward · TA
Target audience	Resilience engineers
Documented capability	Retain data for later delivery when exporting fails.
Input → output	Failed export → stored retry work and eventual delivery outcome.
Execution environment	Compatible EdgeX 4.0 services, SDKs and configured device adapters
Our decision constraint	Storage capacity and retry policies bound resilience.
Our suggested validation	Test destination recovery and duplicate-delivery handling.

Official reference · Store and Forward ↗

Versioned documentation

Versioned documentation · Supporting reference analysis
TA	Platform architects
Our validation advice	This guide selects 4.0 documentation; align service images and SDK releases rather than mixing versions.

Official reference · Versioned documentation ↗

04 / INPUT · EXPECTED OUTPUT · ACCEPTANCE

Expected results before implementation

Illustrative EdgeX reading envelope, not native EdgeX DTO JSON. No device command, service deployment or telemetry export was executed.

Illustrative contract · no API call or model execution · not measured provider output

Reading normalized

Expected behavior — illustrative, not executed
Input	Known device profile and valid sensor reading.
Expected result	ok with resource, value and declared units.
Acceptance	Compare conversion and timestamp to a device fixture.

Empty query window

Expected behavior — illustrative, not executed
Input	Valid time-range query has no readings.
Expected result	ok with readings: [].
Acceptance	Do not interpret empty history as zero physical measurement.

Destination unavailable

Expected behavior — illustrative, not executed
Input	Export fails while configured store-and-forward is available.
Expected result	pending/stored; external persistence remains unconfirmed.
Acceptance	Verify retention, retry limit and duplicate behavior after recovery.

Profile mismatch

Expected behavior — illustrative, not executed
Input	Incoming reading cannot map to declared resource type.
Expected result	error; no fabricated normalized value.
Acceptance	Report profile/resource context and reject unsafe conversion.

Map the expected result to your application

Map the actual SDK or service response into this proposed internal contract after integration. All IDs and values below are invented examples; no credentials or live requests are included.

Expected output JSON — illustrative, not measured · EdgeXFoundry-expected-results.json

{
  "schema_version": "1.0.0",
  "example": true,
  "provider": "EdgeX Foundry",
  "status": "ok",
  "input_id": "sample-001",
  "data": {
    "device": "example-sensor",
    "resource": "Temperature",
    "readings": [
      {
        "value": 24,
        "unit": "C",
        "observed_at": null
      }
    ],
    "export_confirmed": false
  },
  "error": null,
  "verification": "illustrative-only;not-provider-response"
}

Download specification, example and acceptance plan

Engineering handoff — our proposed contract and gates
Result interpretation	Successful transport or execution does not establish model accuracy. Preserve valid empty results separately from operational failure.
Reproducibility	Record model, runtime, configuration and input identifiers; agree quality and latency criteria before representative tests. No measured performance is claimed.
Operation boundary	Illustrative EdgeX reading envelope, not native EdgeX DTO JSON. No device command, service deployment or telemetry export was executed.

Development assessment

Factory edge data bridge

Development concept · integration not tested

Provider capabilities above are based on official documentation or repositories. The proposed product, inputs, deliverable and acceptance criteria below are our development assessment.

Integration pilot

Validate runtime, schemas or hardware together before estimating a deployable product.

Proposed inputs: A test device or simulator, a tag map and documented units.
Proposed deliverable: Timestamped device values with freshness, unit and connection state.
Acceptance criterion: Verify scaling and timestamps against the source; a disconnected device must not appear healthy.
Dependencies: A gateway or service account, an equipment schema and access to a test environment.

Integration condition

Technical references are pinned to EdgeX 4.0 documentation, not a claim that 4.0 is the newest release. Repository main is development code; select compatible released service and SDK versions.

Development sequence

Confirm access to EdgeX Foundry, license and the exact supported version.
Prepare the sample above and implement one documented operation for “Factory edge data bridge”.
Normalize the result with source, time and explicit error state; keep the provider response for review.
Run the acceptance criterion before estimating rollout effort or committing a customer deliverable.

How to validate demand

Record product views, documentation clicks, specification downloads and contextual hub clicks. These are event counts, not unique people or completed integrations.

This feasibility assessment uses implementation conditions. No traffic-based rank or delivery-time promise is assigned.

EdgeX Foundry

Choose an interface. Define a verifiable result.

Company / project overview

Top 10 technical entry points

Reference analysis

Versioned documentation

Expected results before implementation

Reading normalized

Empty query window

Destination unavailable

Profile mismatch

Map the expected result to your application

Factory edge data bridge

Integration condition

Development sequence

How to validate demand

Related products