Health

A public liveness check that proves the v2 stack is wired and reachable.

GET /ping

Public health check. Auth: public. License: n/a.

Parameters

None.

Example request

cURL

curl --location 'https://app.shipos.co.il/api/v2/ping' \
--header 'Accept: application/json'

JavaScript

// Node.js 18+ / browsers — no dependencies
const response = await fetch('https://app.shipos.co.il/api/v2/ping', {
  headers: { Accept: 'application/json' },
})

if (!response.ok) {
  throw new Error(`ShipOS unreachable: ${response.status}`)
}

const { data } = await response.json()

console.log(data.status, data.version) // ok v2

PHP

<?php
// composer require guzzlehttp/guzzle

$client = new \GuzzleHttp\Client([
    'base_uri' => 'https://app.shipos.co.il/api/v2/',
    'headers' => ['Accept' => 'application/json'],
]);

$ping = json_decode(
    $client->get('ping')->getBody()->getContents(),
    true,
)['data'];

echo $ping['status'], ' ', $ping['version'], PHP_EOL; // ok v2

Laravel

<?php

use Illuminate\Support\Facades\Http;

$ping = Http::acceptJson()
    ->get('https://app.shipos.co.il/api/v2/ping')
    ->throw()
    ->json('data');

logger()->info($ping['status'].' '.$ping['version']); // ok v2

Python

# pip install httpx
import httpx

response = httpx.get(
    "https://app.shipos.co.il/api/v2/ping",
    headers={"Accept": "application/json"},
)
response.raise_for_status()
ping = response.json()["data"]

print(ping["status"], ping["version"])  # ok v2

Go

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
)

type pingResponse struct {
	Data struct {
		Status  string `json:"status"`
		Version string `json:"version"`
	} `json:"data"`
}

func main() {
	req, _ := http.NewRequest("GET", "https://app.shipos.co.il/api/v2/ping", nil)
	req.Header.Set("Accept", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	var ping pingResponse
	if err := json.NewDecoder(res.Body).Decode(&ping); err != nil {
		panic(err)
	}

	fmt.Println(ping.Data.Status, ping.Data.Version) // ok v2
}

Java

// Java 17+ — java.net.http, no dependencies (parse with Jackson/Gson)
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ShipOsPing {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://app.shipos.co.il/api/v2/ping"))
            .header("Accept", "application/json")
            .build();

        HttpResponse<String> response =
            client.send(request, HttpResponse.BodyHandlers.ofString());

        if (response.statusCode() != 200) {
            throw new RuntimeException("ShipOS unreachable: " + response.statusCode());
        }

        System.out.println(response.body()); // {"data":{"status":"ok","version":"v2"}}
    }
}

C#

// .NET 8+ — System.Net.Http.Json
using System.Net.Http.Json;
using System.Text.Json;

using var http = new HttpClient
{
    BaseAddress = new Uri("https://app.shipos.co.il/api/v2/"),
};

var payload = await http.GetFromJsonAsync<JsonDocument>("ping")
    ?? throw new InvalidOperationException("Empty response");
var ping = payload.RootElement.GetProperty("data");

Console.WriteLine(
    $"{ping.GetProperty("status").GetString()} {ping.GetProperty("version").GetString()}");

Ruby

require "net/http"
require "json"

uri = URI("https://app.shipos.co.il/api/v2/ping")
request = Net::HTTP::Get.new(uri)
request["Accept"] = "application/json"

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

raise "ShipOS unreachable: #{response.code}" unless response.is_a?(Net::HTTPSuccess)

ping = JSON.parse(response.body).fetch("data")

puts "#{ping["status"]} #{ping["version"]}" # ok v2

Rust

// [dependencies]
// reqwest = { version = "0.12", features = ["json"] }
// tokio = { version = "1", features = ["full"] }
// serde_json = "1"
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let payload: Value = reqwest::Client::new()
        .get("https://app.shipos.co.il/api/v2/ping")
        .header("Accept", "application/json")
        .send()
        .await?
        .error_for_status()?
        .json()
        .await?;

    let ping = &payload["data"];
    println!("{} {}", ping["status"], ping["version"]);
    Ok(())
}

Response 200

{
  "data": {
    "status": "ok",
    "version": "v2"
  }
}

Errors

This endpoint takes no input and requires no auth, so it does not return application errors under normal operation.