Ordinary Wallkit identity

Example: establish a reader session

reader@example.com is an existing active member in the selected ordinary Wallkit resource. These requests use the same JSON fields. Supply WALLKIT_API_BASE (scheme/host only) and RESOURCE_KEY from the existing integration. See sample runtimes.

cURL

curl -X POST "${WALLKIT_API_BASE}/api/v1/authorization" \
  -H "resource: ${RESOURCE_KEY}" \
  -H "Content-Type: application/json" \
  --data '{"email":"reader@example.com","password":"EXAMPLE_PASSWORD_DO_NOT_USE"}'

JavaScript

// Node.js 18+; built-in fetch.
async function main() {
  const url = new URL("/api/v1/authorization", process.env.WALLKIT_API_BASE);
  const response = await fetch(url, {
    method: "POST",
    headers: {
      resource: process.env.RESOURCE_KEY,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
  "email": "reader@example.com",
  "password": "EXAMPLE_PASSWORD_DO_NOT_USE"
})
  });
  console.log(response.status, await response.json());
}
main().catch(console.error);

Python

# Python 3; standard library only.
import json
import os
from urllib.error import HTTPError
from urllib.parse import urljoin
from urllib.request import Request, urlopen

url = urljoin(os.environ["WALLKIT_API_BASE"], "/api/v1/authorization")
body = {'email': 'reader@example.com', 'password': 'EXAMPLE_PASSWORD_DO_NOT_USE'}
request = Request(
    url,
    data=json.dumps(body).encode("utf-8"),
    headers={"resource": os.environ["RESOURCE_KEY"], "Content-Type": "application/json"},
    method="POST",
)
try:
    with urlopen(request) as response:
        print(response.status, json.load(response))
except HTTPError as error:
    print(error.code, json.load(error))

HTTP 200 response excerpt:

{
  "id": 1001,
  "email": "reader@example.com",
  "active": true,
  "token_type": "bearer",
  "token": "EXAMPLE_WALLKIT_SESSION_TOKEN",
  "refresh_token": "EXAMPLE_WALLKIT_REFRESH_TOKEN",
  "session_id": 3001,
  "subscriptions": [],
  "teams": []
}

The session token establishes member context. Empty subscriptions/teams do not deny or grant the article: obtain the actual content access decision. Expiration, profile and conditional relationships are omitted from this excerpt but defined in the linked object tables.

Example

Exchange the existing Wallkit refresh value in token mode. See identity context for configuration and sample conventions.

cURL

curl -X POST "${WALLKIT_API_BASE}/api/v1/authorization/refresh" \
  -H "resource: ${RESOURCE_KEY}" \
  -H "Content-Type: application/json" \
  --data '{"refresh_token":"EXAMPLE_EXISTING_REFRESH_TOKEN","response_type":"token"}'

JavaScript

// Node.js 18+; built-in fetch.
async function main() {
  const url = new URL("/api/v1/authorization/refresh", process.env.WALLKIT_API_BASE);
  const response = await fetch(url, {
    method: "POST",
    headers: {
      resource: process.env.RESOURCE_KEY,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
  "refresh_token": "EXAMPLE_EXISTING_REFRESH_TOKEN",
  "response_type": "token"
})
  });
  console.log(response.status, await response.json());
}
main().catch(console.error);

Python

# Python 3; standard library only.
import json
import os
from urllib.error import HTTPError
from urllib.parse import urljoin
from urllib.request import Request, urlopen

url = urljoin(os.environ["WALLKIT_API_BASE"], "/api/v1/authorization/refresh")
body = {'refresh_token': 'EXAMPLE_EXISTING_REFRESH_TOKEN', 'response_type': 'token'}
request = Request(
    url,
    data=json.dumps(body).encode("utf-8"),
    headers={"resource": os.environ["RESOURCE_KEY"], "Content-Type": "application/json"},
    method="POST",
)
try:
    with urlopen(request) as response:
        print(response.status, json.load(response))
except HTTPError as error:
    print(error.code, json.load(error))

HTTP 200 response excerpt:

{
  "token_type": "bearer",
  "token": "EXAMPLE_NEW_WALLKIT_TOKEN",
  "refresh_token": "EXAMPLE_NEW_REFRESH_TOKEN"
}

Example

End the resolved member session. See identity context for configuration and sample conventions.

cURL

curl "${WALLKIT_API_BASE}/api/v1/logout" \
  -H "resource: ${RESOURCE_KEY}" \
  -H "token: ${USER_TOKEN}"

JavaScript

// Node.js 18+; built-in fetch. Supply existing integration configuration.
async function main() {
  const url = new URL("/api/v1/logout", process.env.WALLKIT_API_BASE);
  const headers = { resource: process.env.RESOURCE_KEY, token: process.env.USER_TOKEN };
  const response = await fetch(url, { method: "GET", headers });
  const body = await response.json();
  console.log(response.status, body);
}
main().catch(console.error);

Python

# Python 3; standard library only.
import json
import os
from urllib.error import HTTPError
from urllib.parse import urlencode, urljoin
from urllib.request import Request, urlopen

url = urljoin(os.environ["WALLKIT_API_BASE"], "/api/v1/logout")
headers = {"resource": os.environ["RESOURCE_KEY"], "token": os.environ["USER_TOKEN"]}
request = Request(url, headers=headers, method="GET")
try:
    with urlopen(request) as response:
        print(response.status, json.load(response))
except HTTPError as error:
    print(error.code, json.load(error))

HTTP 200 response excerpt:

{
  "result": true
}

Example

Sign in with the already-linked Google identity. See identity context for configuration and sample conventions.

cURL

curl -X POST "${WALLKIT_API_BASE}/api/v1/social-authorization" \
  -H "resource: ${RESOURCE_KEY}" \
  -H "Content-Type: application/json" \
  --data '{"method":"google","data":{"id":"EXAMPLE_GOOGLE_ACCOUNT_ID","access_token":"EXAMPLE_GOOGLE_ACCESS_TOKEN"}}'

JavaScript

// Node.js 18+; built-in fetch.
async function main() {
  const url = new URL("/api/v1/social-authorization", process.env.WALLKIT_API_BASE);
  const response = await fetch(url, {
    method: "POST",
    headers: {
      resource: process.env.RESOURCE_KEY,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
  "method": "google",
  "data": {
    "id": "EXAMPLE_GOOGLE_ACCOUNT_ID",
    "access_token": "EXAMPLE_GOOGLE_ACCESS_TOKEN"
  }
})
  });
  console.log(response.status, await response.json());
}
main().catch(console.error);

Python

# Python 3; standard library only.
import json
import os
from urllib.error import HTTPError
from urllib.parse import urljoin
from urllib.request import Request, urlopen

url = urljoin(os.environ["WALLKIT_API_BASE"], "/api/v1/social-authorization")
body = {'method': 'google', 'data': {'id': 'EXAMPLE_GOOGLE_ACCOUNT_ID', 'access_token': 'EXAMPLE_GOOGLE_ACCESS_TOKEN'}}
request = Request(
    url,
    data=json.dumps(body).encode("utf-8"),
    headers={"resource": os.environ["RESOURCE_KEY"], "Content-Type": "application/json"},
    method="POST",
)
try:
    with urlopen(request) as response:
        print(response.status, json.load(response))
except HTTPError as error:
    print(error.code, json.load(error))

HTTP 200 response excerpt:

{
  "id": 1001,
  "token": "EXAMPLE_WALLKIT_SESSION_TOKEN",
  "token_type": "bearer"
}

Example

Register new-reader@example.com in this resource. See identity context for configuration and sample conventions.

cURL

curl -X POST "${WALLKIT_API_BASE}/api/v1/registration" \
  -H "resource: ${RESOURCE_KEY}" \
  -H "Content-Type: application/json" \
  --data '{"email":"new-reader@example.com","password":"EXAMPLE_PASSWORD_DO_NOT_USE","password_confirm":"EXAMPLE_PASSWORD_DO_NOT_USE"}'

JavaScript

// Node.js 18+; built-in fetch.
async function main() {
  const url = new URL("/api/v1/registration", process.env.WALLKIT_API_BASE);
  const response = await fetch(url, {
    method: "POST",
    headers: {
      resource: process.env.RESOURCE_KEY,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
  "email": "new-reader@example.com",
  "password": "EXAMPLE_PASSWORD_DO_NOT_USE",
  "password_confirm": "EXAMPLE_PASSWORD_DO_NOT_USE"
})
  });
  console.log(response.status, await response.json());
}
main().catch(console.error);

Python

# Python 3; standard library only.
import json
import os
from urllib.error import HTTPError
from urllib.parse import urljoin
from urllib.request import Request, urlopen

url = urljoin(os.environ["WALLKIT_API_BASE"], "/api/v1/registration")
body = {'email': 'new-reader@example.com', 'password': 'EXAMPLE_PASSWORD_DO_NOT_USE', 'password_confirm': 'EXAMPLE_PASSWORD_DO_NOT_USE'}
request = Request(
    url,
    data=json.dumps(body).encode("utf-8"),
    headers={"resource": os.environ["RESOURCE_KEY"], "Content-Type": "application/json"},
    method="POST",
)
try:
    with urlopen(request) as response:
        print(response.status, json.load(response))
except HTTPError as error:
    print(error.code, json.load(error))

HTTP 201 response excerpt:

{
  "id": 1001,
  "email": "new-reader@example.com",
  "confirm": false,
  "token": "EXAMPLE_WALLKIT_SESSION_TOKEN"
}

Example

Exchange the received reset code for a session; set the new password separately. See identity context for configuration and sample conventions.

cURL

curl -X POST "${WALLKIT_API_BASE}/api/v1/confirm-password" \
  -H "resource: ${RESOURCE_KEY}" \
  -H "Content-Type: application/json" \
  --data '{"code":"EXAMPLE_RESET_CODE"}'

JavaScript

// Node.js 18+; built-in fetch.
async function main() {
  const url = new URL("/api/v1/confirm-password", process.env.WALLKIT_API_BASE);
  const response = await fetch(url, {
    method: "POST",
    headers: {
      resource: process.env.RESOURCE_KEY,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
  "code": "EXAMPLE_RESET_CODE"
})
  });
  console.log(response.status, await response.json());
}
main().catch(console.error);

Python

# Python 3; standard library only.
import json
import os
from urllib.error import HTTPError
from urllib.parse import urljoin
from urllib.request import Request, urlopen

url = urljoin(os.environ["WALLKIT_API_BASE"], "/api/v1/confirm-password")
body = {'code': 'EXAMPLE_RESET_CODE'}
request = Request(
    url,
    data=json.dumps(body).encode("utf-8"),
    headers={"resource": os.environ["RESOURCE_KEY"], "Content-Type": "application/json"},
    method="POST",
)
try:
    with urlopen(request) as response:
        print(response.status, json.load(response))
except HTTPError as error:
    print(error.code, json.load(error))

HTTP 200 response excerpt:

{
  "token": "EXAMPLE_WALLKIT_SESSION_TOKEN",
  "confirm": false
}

Example

Request a reset for reader@example.com. See identity context for configuration and sample conventions.

cURL

curl -X POST "${WALLKIT_API_BASE}/api/v1/reset-password" \
  -H "resource: ${RESOURCE_KEY}" \
  -H "Content-Type: application/json" \
  --data '{"email":"reader@example.com"}'

JavaScript

// Node.js 18+; built-in fetch.
async function main() {
  const url = new URL("/api/v1/reset-password", process.env.WALLKIT_API_BASE);
  const response = await fetch(url, {
    method: "POST",
    headers: {
      resource: process.env.RESOURCE_KEY,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
  "email": "reader@example.com"
})
  });
  console.log(response.status, await response.json());
}
main().catch(console.error);

Python

# Python 3; standard library only.
import json
import os
from urllib.error import HTTPError
from urllib.parse import urljoin
from urllib.request import Request, urlopen

url = urljoin(os.environ["WALLKIT_API_BASE"], "/api/v1/reset-password")
body = {'email': 'reader@example.com'}
request = Request(
    url,
    data=json.dumps(body).encode("utf-8"),
    headers={"resource": os.environ["RESOURCE_KEY"], "Content-Type": "application/json"},
    method="POST",
)
try:
    with urlopen(request) as response:
        print(response.status, json.load(response))
except HTTPError as error:
    print(error.code, json.load(error))

HTTP 200 response excerpt:

{
  "result": true
}

Example

Request another confirmation for the resolved member. See identity context for configuration and sample conventions.

cURL

curl -X POST "${WALLKIT_API_BASE}/api/v1/resend-confirmation" \
  -H "resource: ${RESOURCE_KEY}" \
  -H "token: ${USER_TOKEN}"

JavaScript

// Node.js 18+; built-in fetch.
async function main() {
  const url = new URL("/api/v1/resend-confirmation", process.env.WALLKIT_API_BASE);
  const response = await fetch(url, {
    method: "POST",
    headers: {
      resource: process.env.RESOURCE_KEY,
      token: process.env.USER_TOKEN,

    }
  });
  console.log(response.status, await response.json());
}
main().catch(console.error);

Python

# Python 3; standard library only.
import json
import os
from urllib.error import HTTPError
from urllib.parse import urljoin
from urllib.request import Request, urlopen

url = urljoin(os.environ["WALLKIT_API_BASE"], "/api/v1/resend-confirmation")
request = Request(
    url,
    headers={"resource": os.environ["RESOURCE_KEY"], "token": os.environ["USER_TOKEN"]},
    method="POST",
)
try:
    with urlopen(request) as response:
        print(response.status, json.load(response))
except HTTPError as error:
    print(error.code, json.load(error))

HTTP 200 response excerpt:

{
  "result": true
}

Example

Submit the email-confirmation code received through the configured flow. See identity context for configuration and sample conventions.

cURL

curl -X POST "${WALLKIT_API_BASE}/api/v1/confirm-email" \
  -H "resource: ${RESOURCE_KEY}" \
  -H "Content-Type: application/json" \
  --data '{"code":"EXAMPLE_EMAIL_CONFIRMATION_CODE"}'

JavaScript

// Node.js 18+; built-in fetch.
async function main() {
  const url = new URL("/api/v1/confirm-email", process.env.WALLKIT_API_BASE);
  const response = await fetch(url, {
    method: "POST",
    headers: {
      resource: process.env.RESOURCE_KEY,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
  "code": "EXAMPLE_EMAIL_CONFIRMATION_CODE"
})
  });
  console.log(response.status, await response.json());
}
main().catch(console.error);

Python

# Python 3; standard library only.
import json
import os
from urllib.error import HTTPError
from urllib.parse import urljoin
from urllib.request import Request, urlopen

url = urljoin(os.environ["WALLKIT_API_BASE"], "/api/v1/confirm-email")
body = {'code': 'EXAMPLE_EMAIL_CONFIRMATION_CODE'}
request = Request(
    url,
    data=json.dumps(body).encode("utf-8"),
    headers={"resource": os.environ["RESOURCE_KEY"], "Content-Type": "application/json"},
    method="POST",
)
try:
    with urlopen(request) as response:
        print(response.status, json.load(response))
except HTTPError as error:
    print(error.code, json.load(error))

HTTP 200 response excerpt:

{
  "result": true
}

Example

Check new-reader@example.com before choosing registration. See identity context for configuration and sample conventions.

cURL

curl -X POST "${WALLKIT_API_BASE}/api/v1/email-validation" \
  -H "resource: ${RESOURCE_KEY}" \
  -H "Content-Type: application/json" \
  --data '{"email":"new-reader@example.com"}'

JavaScript

// Node.js 18+; built-in fetch.
async function main() {
  const url = new URL("/api/v1/email-validation", process.env.WALLKIT_API_BASE);
  const response = await fetch(url, {
    method: "POST",
    headers: {
      resource: process.env.RESOURCE_KEY,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
  "email": "new-reader@example.com"
})
  });
  console.log(response.status, await response.json());
}
main().catch(console.error);

Python

# Python 3; standard library only.
import json
import os
from urllib.error import HTTPError
from urllib.parse import urljoin
from urllib.request import Request, urlopen

url = urljoin(os.environ["WALLKIT_API_BASE"], "/api/v1/email-validation")
body = {'email': 'new-reader@example.com'}
request = Request(
    url,
    data=json.dumps(body).encode("utf-8"),
    headers={"resource": os.environ["RESOURCE_KEY"], "Content-Type": "application/json"},
    method="POST",
)
try:
    with urlopen(request) as response:
        print(response.status, json.load(response))
except HTTPError as error:
    print(error.code, json.load(error))

HTTP 200 response excerpt:

{
  "exists": false,
  "exists_in_resource": false
}

Example

For this synthetic scenario, RESOURCE_KEY corresponds to EXAMPLE_RESOURCE_PUBLIC_KEY, and the callback belongs to the configured resource host. Replace both client and header context consistently in trusted server code. See runtime assumptions.

cURL

curl -X POST "${WALLKIT_API_BASE}/api/v1/oauth/token" \
  -H "resource: ${RESOURCE_KEY}" \
  -H "Content-Type: application/json" \
  --data '{"code":"EXAMPLE_AUTHORIZATION_CODE","grant_type":"authorization_code","redirect_uri":"https://example.com/callback","client_id":"EXAMPLE_RESOURCE_PUBLIC_KEY","client_secret":"EXAMPLE_RESOURCE_SECRET_DO_NOT_USE"}'

JavaScript

// Node.js 18+; built-in fetch.
async function main() {
  const url = new URL("/api/v1/oauth/token", process.env.WALLKIT_API_BASE);
  const response = await fetch(url, {
    method: "POST",
    headers: {
      resource: process.env.RESOURCE_KEY,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
  "code": "EXAMPLE_AUTHORIZATION_CODE",
  "grant_type": "authorization_code",
  "redirect_uri": "https://example.com/callback",
  "client_id": "EXAMPLE_RESOURCE_PUBLIC_KEY",
  "client_secret": "EXAMPLE_RESOURCE_SECRET_DO_NOT_USE"
})
  });
  console.log(response.status, await response.json());
}
main().catch(console.error);

Python

# Python 3; standard library only.
import json
import os
from urllib.error import HTTPError
from urllib.parse import urljoin
from urllib.request import Request, urlopen

url = urljoin(os.environ["WALLKIT_API_BASE"], "/api/v1/oauth/token")
body = {'code': 'EXAMPLE_AUTHORIZATION_CODE', 'grant_type': 'authorization_code', 'redirect_uri': 'https://example.com/callback', 'client_id': 'EXAMPLE_RESOURCE_PUBLIC_KEY', 'client_secret': 'EXAMPLE_RESOURCE_SECRET_DO_NOT_USE'}
request = Request(
    url,
    data=json.dumps(body).encode("utf-8"),
    headers={"resource": os.environ["RESOURCE_KEY"], "Content-Type": "application/json"},
    method="POST",
)
try:
    with urlopen(request) as response:
        print(response.status, json.load(response))
except HTTPError as error:
    print(error.code, json.load(error))

HTTP 200 response excerpt:

{
  "id": 3001,
  "token": "EXAMPLE_WALLKIT_SESSION_TOKEN",
  "refresh_token": "EXAMPLE_WALLKIT_REFRESH_TOKEN"
}

Example

Exchange the external integration’s credential for a Wallkit token. See identity context for configuration and sample conventions.

cURL

curl "${WALLKIT_API_BASE}/api/v1/auth/external/EXAMPLE_EXTERNAL_AUTH_TOKEN" \
  -H "resource: ${RESOURCE_KEY}"

JavaScript

// Node.js 18+; built-in fetch. Supply existing integration configuration.
async function main() {
  const url = new URL("/api/v1/auth/external/EXAMPLE_EXTERNAL_AUTH_TOKEN", process.env.WALLKIT_API_BASE);
  const headers = { resource: process.env.RESOURCE_KEY };
  const response = await fetch(url, { method: "GET", headers });
  const body = await response.json();
  console.log(response.status, body);
}
main().catch(console.error);

Python

# Python 3; standard library only.
import json
import os
from urllib.error import HTTPError
from urllib.parse import urlencode, urljoin
from urllib.request import Request, urlopen

url = urljoin(os.environ["WALLKIT_API_BASE"], "/api/v1/auth/external/EXAMPLE_EXTERNAL_AUTH_TOKEN")
headers = {"resource": os.environ["RESOURCE_KEY"]}
request = Request(url, headers=headers, method="GET")
try:
    with urlopen(request) as response:
        print(response.status, json.load(response))
except HTTPError as error:
    print(error.code, json.load(error))

HTTP 200 response excerpt:

{
  "token": "EXAMPLE_WALLKIT_SESSION_TOKEN"
}