Skip to main content

NavCore Quick Start

Get NavCore running in 5 minutes.

Prerequisites​

Step 1: Install the SDK​

pip install qcos-sdk

Or with pip extras:

pip install qcos-sdk[navcore]

Step 2: Configure API Key​

export QCOS_API_KEY="qcos_live_your_key_here"

Or create a .env file:

QCOS_API_KEY=qcos_live_your_key_here

Step 3: Get Your First Position​

from qcos.navcore import QuantumGPS

# Initialize (reads API key from environment)
gps = QuantumGPS()

# Get authenticated position
position = gps.get_position(
    authenticate=True,
    spoofing_check=True
)

# Print results
print(f"Latitude:  {position.latitude:.6f}")
print(f"Longitude: {position.longitude:.6f}")
print(f"Altitude:  {position.altitude:.1f}m")
print(f"Time:      {position.timestamp}")
print(f"Integrity: {position.integrity_score:.2%}")
print(f"Spoofing:  {'⚠️ DETECTED' if position.spoofing_detected else '✅ Clear'}")

Expected Output:

Latitude:  59.436962
Longitude: 24.753574
Altitude:  45.2m
Time:      2026-02-06T12:00:00.000000Z
Integrity: 98.50%
Spoofing:  ✅ Clear

Step 4: Monitor Position Stream​

from qcos.navcore import QuantumGPS

gps = QuantumGPS()

# Stream positions at 10 Hz
for position in gps.stream(rate_hz=10):
    print(f"[{position.timestamp}] {position.latitude:.6f}, {position.longitude:.6f}")

    if position.spoofing_detected:
        print("⚠️ SPOOFING ALERT!")
        break

Step 5: Get Timing with Holdover​

from qcos.navcore import QuantumTiming

timing = QuantumTiming()

# Get quantum-authenticated time
time_data = timing.get_time(
    source="gps",
    fallback_to_holdover=True
)

print(f"UTC Time: {time_data.utc}")
print(f"TAI Time: {time_data.tai}")
print(f"GPS Week: {time_data.gps_week}")
print(f"Source:   {time_data.source}")  # 'gps' or 'holdover'
print(f"Accuracy: ±{time_data.accuracy_ns}ns")

Step 6: Generate Position Evidence​

from qcos.navcore import QuantumGPS

gps = QuantumGPS()

# Get position with evidence bundle
position = gps.get_position(
    generate_evidence=True,
    pqc_signing=True
)

# Access the evidence bundle
evidence = position.evidence_bundle

print(f"Bundle ID: {evidence.bundle_id}")
print(f"Algorithm: {evidence.signature_algorithm}")

# Export for audit
evidence.export("position_evidence.json")

Step 7: Check Spoofing Status​

from qcos.navcore import SpoofingDetector

detector = SpoofingDetector()

# Run continuous spoofing check
status = detector.check()

print(f"Status: {status.status}")  # 'clear', 'warning', 'alert'
print(f"Confidence: {status.confidence:.2%}")

if status.status != 'clear':
    print(f"Threat Type: {status.threat_type}")
    print(f"Recommended: {status.recommended_action}")

Complete Example​

Here's a complete example combining all features:

#!/usr/bin/env python3
"""NavCore Complete Example"""

from qcos.navcore import QuantumGPS, QuantumTiming, SpoofingDetector

def main():
    # Initialize components
    gps = QuantumGPS()
    timing = QuantumTiming()
    detector = SpoofingDetector()

    # 1. Check for spoofing first
    spoofing = detector.check()
    if spoofing.status == 'alert':
        print("🚨 SPOOFING DETECTED - Entering holdover mode")
        return

    # 2. Get authenticated position
    position = gps.get_position(
        authenticate=True,
        spoofing_check=True,
        generate_evidence=True
    )

    # 3. Get quantum timing
    time_data = timing.get_time(fallback_to_holdover=True)

    # 4. Print results
    print("=" * 50)
    print("NavCore Position Report")
    print("=" * 50)
    print(f"Position: {position.latitude:.6f}°N, {position.longitude:.6f}°E")
    print(f"Altitude: {position.altitude:.1f}m")
    print(f"UTC Time: {time_data.utc}")
    print(f"Timing Source: {time_data.source}")
    print(f"Timing Accuracy: ±{time_data.accuracy_ns}ns")
    print(f"Integrity Score: {position.integrity_score:.2%}")
    print(f"Spoofing Status: {'Clear' if not position.spoofing_detected else 'ALERT'}")
    print(f"Evidence Bundle: {position.evidence_bundle.bundle_id}")
    print("=" * 50)

    # 5. Export evidence for audit
    position.evidence_bundle.export("latest_position.json")
    print("Evidence saved to latest_position.json")

if __name__ == "__main__":
    main()

Using the REST API Directly​

If you prefer REST API over the SDK:

Get Position​

curl -X POST https://api.softquantus.com/api/v2/navcore/position \
  -H "Authorization: Bearer $QCOS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "authenticate": true,
    "spoofing_check": true,
    "generate_evidence": true
  }'

Get Timing​

curl -X POST https://api.softquantus.com/api/v2/navcore/timing \
  -H "Authorization: Bearer $QCOS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "fallback_to_holdover": true
  }'

Check Spoofing​

curl https://api.softquantus.com/api/v2/navcore/spoofing/status \
  -H "Authorization: Bearer $QCOS_API_KEY"

Configuration Options​

from qcos.navcore import QuantumGPS, NavCoreConfig

config = NavCoreConfig(
    # Positioning
    update_rate_hz=10,
    min_satellites=4,

    # Security
    require_authentication=True,
    spoofing_detection=True,
    pqc_algorithm="ML-DSA-65",

    # Holdover
    enable_holdover=True,
    max_holdover_duration_s=3600,

    # Evidence
    auto_generate_evidence=True,
    evidence_storage="cloud"
)

gps = QuantumGPS(config=config)

Next Steps​

© 2024-2026 SoftQuantus Innovative OÜ