Account

Written for: ＋ Written for
Deprecated: ＋ Deprecated
Applies to: ＋ Applies to

AdminUpdated Sep 24, 2026

POSThttps://shippified.net/api/account/timezone

Set the user's IANA timezone (drives free-plan quota window).

Request body application/json

{
  "timezone": "string"
}

Responses

200 Updated.

400 Invalid timezone.

Code samples

cURL

curl -X POST "https://shippified.net/api/account/timezone" \
  -H "Content-Type: application/json" \
  -d '{"timezone":"string"}'

TypeScript

const res = await fetch('https://shippified.net/api/account/timezone', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({"timezone":"string"}),
});
const data = await res.json();

Python

import requests

res = requests.request(
    "POST",
    "https://shippified.net/api/account/timezone",
    headers={
    "Content-Type": "application/json",
    },
    json={"timezone": "string"},
)
data = res.json()

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	req, _ := http.NewRequest("POST", "https://shippified.net/api/account/timezone", strings.NewReader(`{"timezone":"string"}`))
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

PHP

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://shippified.net/api/account/timezone');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
curl_setopt($ch, CURLOPT_POSTFIELDS, '{"timezone":"string"}');
$response = curl_exec($ch);
curl_close($ch);
echo $response;

Ruby

require 'net/http'
require 'uri'

uri = URI('https://shippified.net/api/account/timezone')
req = Net::HTTP::Post.new(uri)
req['Content-Type'] = 'application/json'
req.body = '{"timezone":"string"}'
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts res.body

Java

import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://shippified.net/api/account/timezone"))
    .header("Content-Type", "application/json")
    .method("POST", BodyPublishers.ofString("{\"timezone\":\"string\"}"))
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

POSThttps://shippified.net/api/account/username

Change your URL handle.

Responses

200 Updated.

Code samples

cURL

curl -X POST "https://shippified.net/api/account/username"

TypeScript

const res = await fetch('https://shippified.net/api/account/username', {
  method: 'POST',
});
const data = await res.json();

Python

import requests

res = requests.request(
    "POST",
    "https://shippified.net/api/account/username",
)
data = res.json()

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://shippified.net/api/account/username", nil)
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

PHP

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://shippified.net/api/account/username');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

Ruby

require 'net/http'
require 'uri'

uri = URI('https://shippified.net/api/account/username')
req = Net::HTTP::Post.new(uri)
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts res.body

Java

import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://shippified.net/api/account/username"))
    .method("POST", BodyPublishers.noBody())
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

POSThttps://shippified.net/api/account/visibility

Toggle profile public/private.

Responses

200 Updated.

Code samples

cURL

curl -X POST "https://shippified.net/api/account/visibility"

TypeScript

const res = await fetch('https://shippified.net/api/account/visibility', {
  method: 'POST',
});
const data = await res.json();

Python

import requests

res = requests.request(
    "POST",
    "https://shippified.net/api/account/visibility",
)
data = res.json()

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://shippified.net/api/account/visibility", nil)
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

PHP

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://shippified.net/api/account/visibility');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

Ruby

require 'net/http'
require 'uri'

uri = URI('https://shippified.net/api/account/visibility')
req = Net::HTTP::Post.new(uri)
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts res.body

Java

import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://shippified.net/api/account/visibility"))
    .method("POST", BodyPublishers.noBody())
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

GEThttps://shippified.net/api/account/api-keys

List your API keys (without secrets).

Responses

200 OK

Code samples

cURL

curl -X GET "https://shippified.net/api/account/api-keys"

TypeScript

const res = await fetch('https://shippified.net/api/account/api-keys', {
  method: 'GET',
});
const data = await res.json();

Python

import requests

res = requests.request(
    "GET",
    "https://shippified.net/api/account/api-keys",
)
data = res.json()

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://shippified.net/api/account/api-keys", nil)
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

PHP

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://shippified.net/api/account/api-keys');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

Ruby

require 'net/http'
require 'uri'

uri = URI('https://shippified.net/api/account/api-keys')
req = Net::HTTP::Get.new(uri)
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts res.body

Java

import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://shippified.net/api/account/api-keys"))
    .GET()
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

POSThttps://shippified.net/api/account/api-keys

Mint a new API key. The raw secret is returned once, in this response body only.

Responses

201 Created.

{
  "key": "string",
  "record": {
    "id": "string",
    "name": "string",
    "prefix": "string",
    "createdAt": "2024-01-01T00:00:00Z",
    "lastUsedAt": "2024-01-01T00:00:00Z"
  }
}

429 Key limit reached (25).

Code samples

cURL

curl -X POST "https://shippified.net/api/account/api-keys"

TypeScript

const res = await fetch('https://shippified.net/api/account/api-keys', {
  method: 'POST',
});
const data = await res.json();

Python

import requests

res = requests.request(
    "POST",
    "https://shippified.net/api/account/api-keys",
)
data = res.json()

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://shippified.net/api/account/api-keys", nil)
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

PHP

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://shippified.net/api/account/api-keys');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

Ruby

require 'net/http'
require 'uri'

uri = URI('https://shippified.net/api/account/api-keys')
req = Net::HTTP::Post.new(uri)
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts res.body

Java

import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://shippified.net/api/account/api-keys"))
    .method("POST", BodyPublishers.noBody())
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

DELETEhttps://shippified.net/api/account/api-keys/{id}

Revoke API key.

Parameters

Name	In	Type	Required	Description
`id`	path	string	yes

Responses

200 Revoked.

Code samples

cURL

curl -X DELETE "https://shippified.net/api/account/api-keys/{id}"

TypeScript

const res = await fetch('https://shippified.net/api/account/api-keys/{id}', {
  method: 'DELETE',
});
const data = await res.json();

Python

import requests

res = requests.request(
    "DELETE",
    "https://shippified.net/api/account/api-keys/{id}",
)
data = res.json()

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("DELETE", "https://shippified.net/api/account/api-keys/{id}", nil)
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

PHP

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://shippified.net/api/account/api-keys/{id}');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

Ruby

require 'net/http'
require 'uri'

uri = URI('https://shippified.net/api/account/api-keys/{id}')
req = Net::HTTP::Delete.new(uri)
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts res.body

Java

import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://shippified.net/api/account/api-keys/{id}"))
    .method("DELETE", BodyPublishers.noBody())
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

GEThttps://shippified.net/api/webhook-logs

Audit log of inbound webhooks + email imports.

Responses

200 OK

Code samples

cURL

curl -X GET "https://shippified.net/api/webhook-logs"

TypeScript

const res = await fetch('https://shippified.net/api/webhook-logs', {
  method: 'GET',
});
const data = await res.json();

Python

import requests

res = requests.request(
    "GET",
    "https://shippified.net/api/webhook-logs",
)
data = res.json()

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://shippified.net/api/webhook-logs", nil)
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

PHP

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://shippified.net/api/webhook-logs');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

Ruby

require 'net/http'
require 'uri'

uri = URI('https://shippified.net/api/webhook-logs')
req = Net::HTTP::Get.new(uri)
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts res.body

Java

import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://shippified.net/api/webhook-logs"))
    .GET()
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

DELETEhttps://shippified.net/api/webhook-logs

Clear the audit log.

Responses

200 Cleared.

Code samples

cURL

curl -X DELETE "https://shippified.net/api/webhook-logs"

TypeScript

const res = await fetch('https://shippified.net/api/webhook-logs', {
  method: 'DELETE',
});
const data = await res.json();

Python

import requests

res = requests.request(
    "DELETE",
    "https://shippified.net/api/webhook-logs",
)
data = res.json()

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("DELETE", "https://shippified.net/api/webhook-logs", nil)
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

PHP

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://shippified.net/api/webhook-logs');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

Ruby

require 'net/http'
require 'uri'

uri = URI('https://shippified.net/api/webhook-logs')
req = Net::HTTP::Delete.new(uri)
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts res.body

Java

import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://shippified.net/api/webhook-logs"))
    .method("DELETE", BodyPublishers.noBody())
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

GEThttps://shippified.net/api/account/username/available

Check whether a username is free.

Public, no auth needed. Case-insensitive exact match against existing usernames. It doesn't apply the format, length or reserved-name rules — `POST /api/account/username` can still refuse a name reported as available.

Parameters

Name	In	Type	Required	Description
`u`	query	string	yes	Candidate username.

Responses

200 `reason: "empty"` when `u` is missing or blank.

{
  "available": true,
  "reason": "empty"
}

Code samples

cURL

curl -X GET "https://shippified.net/api/account/username/available?u="

TypeScript

const res = await fetch('https://shippified.net/api/account/username/available?u=', {
  method: 'GET',
});
const data = await res.json();

Python

import requests

res = requests.request(
    "GET",
    "https://shippified.net/api/account/username/available?u=",
)
data = res.json()

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://shippified.net/api/account/username/available?u=", nil)
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

PHP

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://shippified.net/api/account/username/available?u=');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

Ruby

require 'net/http'
require 'uri'

uri = URI('https://shippified.net/api/account/username/available?u=')
req = Net::HTTP::Get.new(uri)
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts res.body

Java

import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://shippified.net/api/account/username/available?u="))
    .GET()
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

POSThttps://shippified.net/api/account/display-name

Rename the workspace.

The display name is the human label shown on the leaderboard, public profile, share cards and the daily digest. It's separate from the URL username. Whitespace is collapsed and trimmed.

Request body application/json

{
  "displayName": "string"
}

Responses

200 Updated. Returns the stored (cleaned-up) name and the refreshed workspace state.

{
  "displayName": "string",
  "state": {}
}

400 Missing, blank or longer than 48 characters.

{
  "error": "string"
}

401 Not authenticated.

Code samples

cURL

curl -X POST "https://shippified.net/api/account/display-name" \
  -H "Content-Type: application/json" \
  -d '{"displayName":"string"}'

TypeScript

const res = await fetch('https://shippified.net/api/account/display-name', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({"displayName":"string"}),
});
const data = await res.json();

Python

import requests

res = requests.request(
    "POST",
    "https://shippified.net/api/account/display-name",
    headers={
    "Content-Type": "application/json",
    },
    json={"displayName": "string"},
)
data = res.json()

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	req, _ := http.NewRequest("POST", "https://shippified.net/api/account/display-name", strings.NewReader(`{"displayName":"string"}`))
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

PHP

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://shippified.net/api/account/display-name');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
curl_setopt($ch, CURLOPT_POSTFIELDS, '{"displayName":"string"}');
$response = curl_exec($ch);
curl_close($ch);
echo $response;

Ruby

require 'net/http'
require 'uri'

uri = URI('https://shippified.net/api/account/display-name')
req = Net::HTTP::Post.new(uri)
req['Content-Type'] = 'application/json'
req.body = '{"displayName":"string"}'
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts res.body

Java

import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://shippified.net/api/account/display-name"))
    .header("Content-Type", "application/json")
    .method("POST", BodyPublishers.ofString("{\"displayName\":\"string\"}"))
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

POSThttps://shippified.net/api/account/public-stats

Opt in or out of public aggregate stats.

Separate from profile visibility (`POST /api/account/visibility`, which only controls whether your profile page loads). When on, your checkouts count toward public-facing stats: your leaderboard rank, the retailer mix and daily activity on your public profile, and the public checkout feed. Off by default.

Request body application/json

{
  "publicStats": true
}

Responses

200 Updated.

{
  "publicStats": true,
  "state": {}
}

400 `publicStats` isn't a boolean.

{
  "error": "string"
}

401 Not authenticated.

Code samples

cURL

curl -X POST "https://shippified.net/api/account/public-stats" \
  -H "Content-Type: application/json" \
  -d '{"publicStats":true}'

TypeScript

const res = await fetch('https://shippified.net/api/account/public-stats', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({"publicStats":true}),
});
const data = await res.json();

Python

import requests

res = requests.request(
    "POST",
    "https://shippified.net/api/account/public-stats",
    headers={
    "Content-Type": "application/json",
    },
    json={"publicStats": True},
)
data = res.json()

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	req, _ := http.NewRequest("POST", "https://shippified.net/api/account/public-stats", strings.NewReader(`{"publicStats":true}`))
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

PHP

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://shippified.net/api/account/public-stats');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
curl_setopt($ch, CURLOPT_POSTFIELDS, '{"publicStats":true}');
$response = curl_exec($ch);
curl_close($ch);
echo $response;

Ruby

require 'net/http'
require 'uri'

uri = URI('https://shippified.net/api/account/public-stats')
req = Net::HTTP::Post.new(uri)
req['Content-Type'] = 'application/json'
req.body = '{"publicStats":true}'
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts res.body

Java

import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://shippified.net/api/account/public-stats"))
    .header("Content-Type", "application/json")
    .method("POST", BodyPublishers.ofString("{\"publicStats\":true}"))
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

POSThttps://shippified.net/api/account/push-token

The mobile app calls this on every launch. Registering the same token again is a no-op.

Request body application/json

{
  "token": "ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]",
  "platform": "ios"
}

Responses

200 Registered.

{
  "ok": true
}

400 Missing or not an Expo push token.

{
  "error": "string"
}

401 Not authenticated.

Code samples

cURL

curl -X POST "https://shippified.net/api/account/push-token" \
  -H "Content-Type: application/json" \
  -d '{"token":"ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]","platform":"ios"}'

TypeScript

const res = await fetch('https://shippified.net/api/account/push-token', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({"token":"ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]","platform":"ios"}),
});
const data = await res.json();

Python

import requests

res = requests.request(
    "POST",
    "https://shippified.net/api/account/push-token",
    headers={
    "Content-Type": "application/json",
    },
    json={"token": "ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]", "platform": "ios"},
)
data = res.json()

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	req, _ := http.NewRequest("POST", "https://shippified.net/api/account/push-token", strings.NewReader(`{"token":"ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]","platform":"ios"}`))
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

PHP

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://shippified.net/api/account/push-token');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
curl_setopt($ch, CURLOPT_POSTFIELDS, '{"token":"ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]","platform":"ios"}');
$response = curl_exec($ch);
curl_close($ch);
echo $response;

Ruby

require 'net/http'
require 'uri'

uri = URI('https://shippified.net/api/account/push-token')
req = Net::HTTP::Post.new(uri)
req['Content-Type'] = 'application/json'
req.body = '{"token":"ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]","platform":"ios"}'
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts res.body

Java

import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://shippified.net/api/account/push-token"))
    .header("Content-Type", "application/json")
    .method("POST", BodyPublishers.ofString("{\"token\":\"ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]\",\"platform\":\"ios\"}"))
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

DELETEhttps://shippified.net/api/account/push-token

Unregister a push token (e.g. on sign-out).

Succeeds even if the token wasn't registered or the body is empty.

Request body application/json

{
  "token": "string"
}

Responses

200 Removed.

{
  "ok": true
}

401 Not authenticated.

Code samples

cURL

curl -X DELETE "https://shippified.net/api/account/push-token" \
  -H "Content-Type: application/json" \
  -d '{"token":"string"}'

TypeScript

const res = await fetch('https://shippified.net/api/account/push-token', {
  method: 'DELETE',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({"token":"string"}),
});
const data = await res.json();

Python

import requests

res = requests.request(
    "DELETE",
    "https://shippified.net/api/account/push-token",
    headers={
    "Content-Type": "application/json",
    },
    json={"token": "string"},
)
data = res.json()

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	req, _ := http.NewRequest("DELETE", "https://shippified.net/api/account/push-token", strings.NewReader(`{"token":"string"}`))
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

PHP

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://shippified.net/api/account/push-token');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
curl_setopt($ch, CURLOPT_POSTFIELDS, '{"token":"string"}');
$response = curl_exec($ch);
curl_close($ch);
echo $response;

Ruby

require 'net/http'
require 'uri'

uri = URI('https://shippified.net/api/account/push-token')
req = Net::HTTP::Delete.new(uri)
req['Content-Type'] = 'application/json'
req.body = '{"token":"string"}'
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts res.body

Java

import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://shippified.net/api/account/push-token"))
    .header("Content-Type", "application/json")
    .method("DELETE", BodyPublishers.ofString("{\"token\":\"string\"}"))
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

GEThttps://shippified.net/api/account/export

Download everything the account owns as JSON.

Browser session only — API keys (`sk_…`) get 401. Includes the profile, settings, orders, email sources, bots, custom templates, subscriptions, shares, API key metadata and every stored intake message. Password hashes, verification/reset tokens, mailbox passwords and OAuth tokens, and API key hashes are left out. Sent with `Content-Disposition: attachment`.

Responses

200 The export file.

{
  "exportedAt": "2024-01-01T00:00:00Z",
  "account": {},
  "settings": {},
  "orders": [
    {
      "id": "ord_mpvu9uim_aeh5t",
      "userId": "string",
      "source": "discord",
      "storeLabel": "string",
      "store": "string",
      "itemSummary": "string",
      "orderNumber": "string",
      "total": "string",
      "salePriceCents": 0,
      "costCents": 0,
      "trackingNumber": "string",
      "carrier": "string",
      "shippingAddress": {
        "name": "string",
        "line1": "string",
        "line2": "string",
        "city": "string",
        "region": "string",
        "postalCode": "string",
        "country": "string"
      },
      "status": "ordered",
      "estimatedDelivery": "string",
      "actualDelivery": "string",
      "receivedAt": "2024-01-01T00:00:00Z"
    }
  ],
  "emailSources": [
    {
      "id": "string",
      "userId": "string",
      "provider": "imap",
      "label": "string",
      "address": "string",
      "status": "connected",
      "templateIds": [
        "string"
      ],
      "allowedSenders": [
        "string"
      ],
      "lastPolledAt": "2024-01-01T00:00:00Z",
      "lastError": "string"
    }
  ],
  "bots": [
    {
      "id": "string",
      "userId": "string",
      "slug": "string",
      "name": "string",
      "avatar": "string",
      "templateId": "string",
      "templateHint": "string",
      "samplePayload": "string",
      "outputWebhook": "string",
      "createdAt": "2024-01-01T00:00:00Z"
    }
  ],
  "customTemplates": [
    {}
  ],
  "subscriptions": [
    {
      "id": "string",
      "userId": "string",
      "name": "string",
      "costCents": 0,
      "currency": "USD",
      "frequency": "weekly",
      "startDate": "string",
      "endDate": "string",
      "category": "string",
      "notes": "string",
      "active": true,
      "createdAt": "2024-01-01T00:00:00Z"
    }
  ],
  "shares": [
    {
      "slug": "string",
      "userId": "string",
      "displayName": "string",
      "createdAt": "2024-01-01T00:00:00Z",
      "timeframe": "7d",
      "include": {
        "stats": true,
        "checkouts": true
      }
    }
  ],
  "apiKeys": [
    {
      "id": "string",
      "name": "string",
      "prefix": "string",
      "createdAt": "2024-01-01T00:00:00Z",
      "lastUsedAt": "2024-01-01T00:00:00Z"
    }
  ],
  "intakeMessages": [
    {}
  ]
}

401 Not signed in, or called with an API key.

Code samples

cURL

curl -X GET "https://shippified.net/api/account/export"

TypeScript

const res = await fetch('https://shippified.net/api/account/export', {
  method: 'GET',
});
const data = await res.json();

Python

import requests

res = requests.request(
    "GET",
    "https://shippified.net/api/account/export",
)
data = res.json()

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://shippified.net/api/account/export", nil)
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

PHP

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://shippified.net/api/account/export');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

Ruby

require 'net/http'
require 'uri'

uri = URI('https://shippified.net/api/account/export')
req = Net::HTTP::Get.new(uri)
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts res.body

Java

import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://shippified.net/api/account/export"))
    .GET()
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

DELETEhttps://shippified.net/api/account

Permanently delete the account and all its data.

Irreversible. Browser session only — API keys (`sk_…`) get 401, so a leaked key can't delete the account. You must type the account's email back (case-insensitive) to confirm.

Request body application/json

{
  "confirmEmail": "string"
}

Responses

200 Deleted.

{
  "ok": true
}

400 `confirmEmail` is missing or doesn't match the account email.

{
  "error": "string"
}

401 Not signed in, or called with an API key.

404 Account not found.

Code samples

cURL

curl -X DELETE "https://shippified.net/api/account" \
  -H "Content-Type: application/json" \
  -d '{"confirmEmail":"string"}'

TypeScript

const res = await fetch('https://shippified.net/api/account', {
  method: 'DELETE',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({"confirmEmail":"string"}),
});
const data = await res.json();

Python

import requests

res = requests.request(
    "DELETE",
    "https://shippified.net/api/account",
    headers={
    "Content-Type": "application/json",
    },
    json={"confirmEmail": "string"},
)
data = res.json()

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	req, _ := http.NewRequest("DELETE", "https://shippified.net/api/account", strings.NewReader(`{"confirmEmail":"string"}`))
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}

PHP

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://shippified.net/api/account');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
curl_setopt($ch, CURLOPT_POSTFIELDS, '{"confirmEmail":"string"}');
$response = curl_exec($ch);
curl_close($ch);
echo $response;

Ruby

require 'net/http'
require 'uri'

uri = URI('https://shippified.net/api/account')
req = Net::HTTP::Delete.new(uri)
req['Content-Type'] = 'application/json'
req.body = '{"confirmEmail":"string"}'
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts res.body

Java

import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://shippified.net/api/account"))
    .header("Content-Type", "application/json")
    .method("DELETE", BodyPublishers.ofString("{\"confirmEmail\":\"string\"}"))
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

Was this page helpful?