Python

pip install requests

import os

import requests

RUNTIME_URL = os.environ.get("FORMERIE_RUNTIME_URL", "https://forms.formerie.com")
# Your form. This is the only line that names it.
FORM = os.environ.get("FORMERIE_FORM", "acme/contact")

response = requests.post(
    f"{RUNTIME_URL}/{FORM}/submit",
    json={
        "fields": {
            "name": "Jane Example",
            "email": "jane@example.com",
            "message": "Hello from my server",
        },
    },
    timeout=10,
)
result = response.json()
print(response.status_code, result["submissionUid"] if result["ok"] else result["error"]["code"])

import os

import requests

RUNTIME_URL = os.environ.get("FORMERIE_RUNTIME_URL", "https://forms.formerie.com")
# Your form. This is the only line that names it.
FORM = os.environ.get("FORMERIE_FORM", "acme/contact")

response = requests.post(
    f"{RUNTIME_URL}/{FORM}/submit",
    # Keep the key out of your code. A test is stored apart and emails nobody.
    headers={"X-Formerie-Test-Key": os.environ["FORMERIE_TEST_KEY"]},
    json={"fields": {"name": "Jane Example", "email": "jane@example.com", "message": "Just a test"}},
    timeout=10,
)
result = response.json()
print(response.status_code, result["submissionUid"] if result["ok"] else result["error"]["code"])

import os

import requests

RUNTIME_URL = os.environ.get("FORMERIE_RUNTIME_URL", "https://forms.formerie.com")
# Your form. This is the only line that names it.
FORM = os.environ.get("FORMERIE_FORM", "acme/contact")


def check_answers(fields, step=None):
    """Checks answers and stores nothing. Without a step, only the fields you send are checked."""
    body = {"mode": "step", "step": step, "fields": fields} if step else {"mode": "partial", "fields": fields}
    response = requests.post(f"{RUNTIME_URL}/{FORM}/validate", json=body, timeout=10)
    result = response.json()
    if result["ok"]:
        return {"valid": True, "values": result["values"]}
    if result["error"]["code"] != "VALIDATION_FAILED":
        raise RuntimeError(result["error"]["code"])
    return {"valid": False, "fields": result["error"]["fields"]}

import html
import os

import requests

RUNTIME_URL = os.environ.get("FORMERIE_RUNTIME_URL", "https://forms.formerie.com")
# Your form. This is the only line that names it.
FORM = os.environ.get("FORMERIE_FORM", "acme/contact")


def submit_answers(fields):
    response = requests.post(f"{RUNTIME_URL}/{FORM}/submit", json={"fields": fields}, timeout=10)
    return response.json()


def field_errors(result):
    """The messages for each field, by path, such as message or contact.email."""
    if result["ok"] or result["error"]["code"] != "VALIDATION_FAILED":
        return {}
    return {path: [issue["message"] for issue in issues] for path, issues in result["error"]["fields"].items()}


def answer_at(answers, path):
    """Finds the visitor's answer for a path, so the form can show it again."""
    value = answers
    for part in path.split("."):
        value = value.get(part, "") if isinstance(value, dict) else ""
    return value


def render_field(path, answers, errors):
    """One input with its answer kept and its first message under it."""
    name = html.escape(path)
    value = html.escape(str(answer_at(answers, path)))
    error = f'<p class="error">{html.escape(errors[path][0])}</p>' if path in errors else ""
    return f'<input name="{name}" value="{value}">{error}'

import os
import random
import time
import uuid

import requests

RUNTIME_URL = os.environ.get("FORMERIE_RUNTIME_URL", "https://forms.formerie.com")
# Your form. This is the only line that names it.
FORM = os.environ.get("FORMERIE_FORM", "acme/contact")
MAX_ATTEMPTS = 3
LONGEST_WAIT = 30
TEMPORARY_CODES = {"FORM_MAINTENANCE", "QUEUE_FAILED", "INTERNAL_ERROR"}


def retry_after(response):
    value = response.headers.get("Retry-After", "")
    return int(value) if value.isdigit() else None


def send_once(fields, key):
    """One attempt. Says what happened, and whether another attempt could help."""
    try:
        response = requests.post(
            f"{RUNTIME_URL}/{FORM}/submit",
            json={"fields": fields, "metadata": {"idempotencyKey": key}},
            timeout=10,
        )
    except requests.RequestException:
        return {"outcome": "retry-later", "reason": "network", "again": True}

    after = retry_after(response)
    # Only the short-term limit sends Retry-After. A form's own limit can last an hour, so don't wait for it.
    if response.status_code == 429:
        return {"outcome": "retry-later", "reason": "rate-limited", "after": after,
                "again": after is not None and after <= LONGEST_WAIT}

    # Something in front of Formerie may answer without JSON, so look at the status first.
    try:
        result = response.json()
    except ValueError:
        return {"outcome": "retry-later", "reason": "bad-response", "again": response.status_code in (502, 503, 504)}

    if result["ok"]:
        return {"outcome": "accepted", "id": result["submissionUid"]}
    error = result["error"]
    if error["code"] == "DUPLICATE_SUBMISSION":
        # The first send worked, and only its answer was lost.
        return {"outcome": "accepted", "duplicate": True}
    if error["code"] in TEMPORARY_CODES:
        return {"outcome": "retry-later", "reason": error["code"], "again": True}
    if error["code"] == "VALIDATION_FAILED":
        return {"outcome": "invalid", "code": error["code"], "issues": error["issues"]}
    return {"outcome": "rejected", "code": error["code"], "message": error["message"]}


def submit_with_retries(fields, key=None):
    # One key per submission, the same on every retry. Store it with the answers if you retry later.
    key = key or str(uuid.uuid4())
    for attempt in range(1, MAX_ATTEMPTS + 1):
        answer = send_once(fields, key)
        if not answer.pop("again", False) or attempt == MAX_ATTEMPTS:
            return {**answer, "key": key, "attempts": attempt}
        backoff = random.uniform(0, min(0.25 * 2 ** attempt, 4))
        time.sleep(max(answer.get("after") or 0, backoff))

import os

import requests

RUNTIME_URL = os.environ.get("FORMERIE_RUNTIME_URL", "https://forms.formerie.com")
# Your form. This is the only line that names it.
FORM = os.environ.get("FORMERIE_FORM", "acme/contact")


def submit_verified(posted, origin):
    """posted is what your form sent. origin is the Origin header of the visitor's request."""
    fields = dict(posted)
    token = fields.pop("cf-turnstile-response", "")
    # Without the visitor's Origin, the provider's hostname can't match, and the check fails.
    headers = {"Origin": origin} if origin else {}
    response = requests.post(
        f"{RUNTIME_URL}/{FORM}/submit",
        headers=headers,
        json={"fields": fields, "verificationToken": token},
        timeout=10,
    )
    return response.json()

import os
import uuid
from datetime import datetime, timedelta, timezone

import requests

RUNTIME_URL = os.environ.get("FORMERIE_RUNTIME_URL", "https://forms.formerie.com")
# Your form. This is the only line that names it.
FORM = os.environ.get("FORMERIE_FORM", "acme/contact")


def submit_with_metadata(fields, started_at, visitor_id):
    response = requests.post(
        f"{RUNTIME_URL}/{FORM}/submit",
        json={
            "fields": fields,
            "metadata": {
                "idempotencyKey": str(uuid.uuid4()),
                # When the visitor opened the form, for the minimum submit time check.
                "startedAt": started_at.isoformat().replace("+00:00", "Z"),
                "pageUrl": "https://www.example.com/contact",
                # Your own visitor ID, for a limit rule with the deviceToken scope.
                "deviceToken": visitor_id,
            },
        },
        timeout=10,
    )
    return response.status_code, response.json()

pip install django requests

import requests
from django.http import JsonResponse
from django.views.decorators.http import require_POST

FORMERIE_RUNTIME_URL = os.environ.get("FORMERIE_RUNTIME_URL", "https://forms.formerie.com")
# Your form. This is the only line that names it.
FORMERIE_FORM = os.environ.get("FORMERIE_FORM", "acme/contact")


@require_POST
def contact(request):
    # Name the fields you send, so a visitor can't add others.
    fields = {name: request.POST.get(name, "") for name in ("name", "email", "message")}
    try:
        answer = requests.post(f"{FORMERIE_RUNTIME_URL}/{FORMERIE_FORM}/submit", json={"fields": fields}, timeout=10)
        result = answer.json()
    except (requests.RequestException, ValueError):
        # No connection, a timeout, or an answer that isn't JSON. Keep the visitor's answers on screen.
        return JsonResponse({"code": "TRY_AGAIN"}, status=503)
    if result["ok"]:
        return JsonResponse({"id": result["submissionUid"]}, status=202)
    errors = {path: [issue["message"] for issue in issues] for path, issues in result["error"].get("fields", {}).items()}
    return JsonResponse({"code": result["error"]["code"], "errors": errors}, status=answer.status_code)