Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/applications/32/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/applications/32/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/applications/32/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 292
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Not Found",
    "errors": {
        "project_id": "Eintrag konnte nicht gefunden werden."
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/people/002f0ff5-71ab-4e25-be80-c7a9eac9da32/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/people/002f0ff5-71ab-4e25-be80-c7a9eac9da32/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/people/002f0ff5-71ab-4e25-be80-c7a9eac9da32/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 291
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Not Found",
    "errors": {
        "project_id": "Eintrag konnte nicht gefunden werden."
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/projects/1/people" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"id\": \"550e8400-e29b-41d4-a716-446655440000\",
    \"personTypes\": [
        \"architecto\"
    ],
    \"actAsBackendCreation\": false,
    \"data\": {
        \"name\": \"Müller\",
        \"firstname\": \"Anna\",
        \"email\": \"anna@example.com\"
    }
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/projects/1/people"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": "550e8400-e29b-41d4-a716-446655440000",
    "personTypes": [
        "architecto"
    ],
    "actAsBackendCreation": false,
    "data": {
        "name": "Müller",
        "firstname": "Anna",
        "email": "anna@example.com"
    }
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/projects/1/people';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'id' => '550e8400-e29b-41d4-a716-446655440000',
            'personTypes' => [
                'architecto',
            ],
            'actAsBackendCreation' => false,
            'data' => [
                'name' => 'Müller',
                'firstname' => 'Anna',
                'email' => 'anna@example.com',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (422):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 290
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Validation failed",
    "errors": {
        "personTypes.0": [
            "One or more personTypes are invalid for this project"
        ]
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/people/002f0ff5-71ab-4e25-be80-c7a9eac9da32" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/people/002f0ff5-71ab-4e25-be80-c7a9eac9da32"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/people/002f0ff5-71ab-4e25-be80-c7a9eac9da32';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 278
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "id": "002f0ff5-71ab-4e25-be80-c7a9eac9da32",
    "data": {
        "city": "Nürnberg",
        "name": "Casino",
        "email": "isabella.casino@gmx.de",
        "country": "DE",
        "firstname": "Isabella",
        "phone_mobile": "+4917646102627"
    },
    "lexware_contact_id": null,
    "calculated_data": [],
    "checked_in_at": null,
    "deleted_at": null,
    "created_at": "2025-11-27T12:18:00.000000Z",
    "updated_at": "2025-11-27T12:18:00.000000Z",
    "deactivated_at": null,
    "anonymized_at": null,
    "project_id": 0,
    "fullname": "Isabella Casino",
    "person_types": [
        {
            "id": 24,
            "name": "Helfer",
            "description": "Helferinnen und Helfer",
            "shortname": "VolunteerPerson",
            "typeable_model": "App\\PersonType",
            "created_at": "2024-11-11T19:52:48.000000Z",
            "updated_at": "2026-03-23T11:23:40.000000Z",
            "order": 1,
            "project_id": null,
            "data": {
                "portal": {
                    "meals": false,
                    "events": false,
                    "eventsTo": null,
                    "guestList": false,
                    "eventsFrom": null,
                    "updateForm": true,
                    "updateFormTo": null,
                    "eventsSettings": {
                        "areaTypes": [],
                        "timeLimit": false,
                        "eventTypes": [],
                        "onlyOneArea": false,
                        "onlyTeamJobs": false,
                        "eventsNotJobs": false,
                        "fullDaySelect": false,
                        "hideEventName": false,
                        "maximumSelection": null,
                        "minimumSelection": null,
                        "hideAssignedEvents": false
                    },
                    "updateFormFrom": null
                },
                "menu_name": "Helfer:in",
                "permissionKey": "helfer"
            },
            "menu_name": "Helfer:in",
            "permissionKey": "helfer",
            "pivot": {
                "typeable_type": "App\\Person",
                "typeable_id": "002f0ff5-71ab-4e25-be80-c7a9eac9da32",
                "type_id": 24
            }
        }
    ],
    "tickets_owned": [],
    "person_access_types": [],
    "applications_as_owner": [],
    "applications_as_member": [],
    "assignees": [],
    "journey": [],
    "nfc_tags": [],
    "comments": [],
    "guests": [],
    "teams": [],
    "teams_suggested": [],
    "teams_confirmed": [],
    "teams_assigned": [],
    "contracts": [],
    "events": [],
    "jobs": []
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request PUT \
    "https://{instance}.festiware.eu/api/v1/people/002f0ff5-71ab-4e25-be80-c7a9eac9da32" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"personTypes\": [
        \"architecto\"
    ],
    \"data\": {
        \"email\": \"new@example.com\",
        \"phone\": \"+49 123 456\"
    },
    \"replaceMissing\": false,
    \"updatedAt\": \"2026-04-10T14:30:00+02:00\"
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/people/002f0ff5-71ab-4e25-be80-c7a9eac9da32"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "personTypes": [
        "architecto"
    ],
    "data": {
        "email": "new@example.com",
        "phone": "+49 123 456"
    },
    "replaceMissing": false,
    "updatedAt": "2026-04-10T14:30:00+02:00"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/people/002f0ff5-71ab-4e25-be80-c7a9eac9da32';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'personTypes' => [
                'architecto',
            ],
            'data' => [
                'email' => 'new@example.com',
                'phone' => '+49 123 456',
            ],
            'replaceMissing' => false,
            'updatedAt' => '2026-04-10T14:30:00+02:00',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (422):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 277
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Validation failed",
    "errors": {
        "personTypes.0": [
            "One or more personTypes are invalid for this project"
        ]
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/application-types" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/application-types"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/application-types';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 276
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

[
    {
        "name": "Künstler/Ensembles",
        "description": "Bands oder Einzelkünstler",
        "shortname": "ArtistApplication",
        "id": 15
    },
    {
        "name": "Händler",
        "description": "Stände für Gastro und Verkauf",
        "shortname": "VendorApplication",
        "id": 16
    },
    {
        "name": "Workshop",
        "description": "Workshopanmeldung",
        "shortname": "WorkshopApplication",
        "id": 17
    },
    {
        "name": "Dienstleister",
        "description": "Technikfirmen, Veranstaltungsorte, usw.",
        "shortname": "ServiceApplication",
        "id": 18
    },
    {
        "name": "Crew",
        "description": "Crews",
        "shortname": "CrewApplication",
        "id": 19
    },
    {
        "name": "Veranstaltungen",
        "description": null,
        "shortname": "VeranstaltungApplication",
        "id": 37
    },
    {
        "name": "Agenturen",
        "description": "Künstleragenturen, welche die Künstler vertreten",
        "shortname": "AgenturApplication",
        "id": 429
    }
]
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/person-types" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/person-types"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/person-types';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 275
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

[
    {
        "name": "Besucher",
        "description": "Festivalbesucherinnen und -besucher",
        "shortname": "VisitorPerson",
        "id": 20
    },
    {
        "name": "Händler",
        "description": "Standbetreiberinnen und -betreiber",
        "shortname": "VendorPerson",
        "id": 21
    },
    {
        "name": "ION-Mitglieder",
        "description": "ION Stab",
        "shortname": "TeamMemberPerson",
        "id": 22
    },
    {
        "name": "Künstler- /Ansprech -",
        "description": "Künstlerinnen und Künstler",
        "shortname": "ArtistPerson",
        "id": 23
    },
    {
        "name": "Helfer",
        "description": "Helferinnen und Helfer",
        "shortname": "VolunteerPerson",
        "id": 24
    },
    {
        "name": "Dienstleister",
        "description": "Dienstleisterinnen und Dienstleister",
        "shortname": "ServicePerson",
        "id": 25
    },
    {
        "name": "Workshopleiter",
        "description": "Workshopleiter und -leiterinnen",
        "shortname": "TeacherPerson",
        "id": 26
    },
    {
        "name": "Crewmitglied",
        "description": "Crewmitglieder",
        "shortname": "CrewPerson",
        "id": 27
    },
    {
        "name": "Mitarbeiter Künstler/Agentur",
        "description": null,
        "shortname": "APderKnstelragenturPerson",
        "id": 430
    }
]
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/projects" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/projects"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/projects';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 274
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

[
    {
        "id": 1,
        "name": "74. Musikfest ION",
        "shortname": "ION-2025",
        "description": "Die erste Veranstaltung mit festiware.",
        "start_date": "2024-12-31T23:00:00.000000Z",
        "end_date": "2025-12-30T23:00:00.000000Z",
        "status": "past",
        "created_at": "2024-11-11T19:52:46.000000Z",
        "updated_at": "2026-01-09T10:27:23.000000Z"
    },
    {
        "id": 35,
        "name": "75. Musikfest ION",
        "shortname": "ION-26",
        "description": null,
        "start_date": "2025-12-31T23:00:00.000000Z",
        "end_date": "2026-12-30T23:00:00.000000Z",
        "status": "current",
        "created_at": "2025-10-18T19:02:45.000000Z",
        "updated_at": "2025-10-20T18:13:39.000000Z"
    },
    {
        "id": 36,
        "name": "76. Musikfest ION",
        "shortname": "ION-27",
        "description": "Musikest ION 2027",
        "start_date": "2026-12-31T23:00:00.000000Z",
        "end_date": "2027-12-30T23:00:00.000000Z",
        "status": "upcoming",
        "created_at": "2026-02-24T14:44:32.000000Z",
        "updated_at": "2026-04-07T21:59:11.000000Z"
    }
]
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/users" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/users"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/users';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (403):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 273
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "This action is unauthorized."
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/users" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"jdoe\",
    \"email\": \"jdoe@example.com\",
    \"password\": \"secureP4ss!\"
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/users"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "jdoe",
    "email": "jdoe@example.com",
    "password": "secureP4ss!"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/users';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'jdoe',
            'email' => 'jdoe@example.com',
            'password' => 'secureP4ss!',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (403):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 272
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "This action is unauthorized."
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/users/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/users/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/users/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (403):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 271
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "This action is unauthorized."
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request PUT \
    "https://{instance}.festiware.eu/api/v1/users/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"jdoe\",
    \"email\": \"jdoe@example.com\",
    \"password\": \"secureP4ss!\"
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/users/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "jdoe",
    "email": "jdoe@example.com",
    "password": "secureP4ss!"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/users/architecto';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'jdoe',
            'email' => 'jdoe@example.com',
            'password' => 'secureP4ss!',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (403):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 270
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "This action is unauthorized."
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request DELETE \
    "https://{instance}.festiware.eu/api/v1/users/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/users/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/users/architecto';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (403):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 269
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "This action is unauthorized."
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/guests/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/guests/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/guests/architecto';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (403):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 233
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "exception": "Signup Link is not valid",
    "message": "Signup Link is not valid."
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/guest" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/guest"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/guest';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (500):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 232
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Server Error"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/events/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/events/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/events/architecto';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (403):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 231
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "exception": "Signup Link is not valid",
    "message": "Signup Link is not valid."
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/events" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/events"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/events';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (500):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 230
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Server Error"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/remove-guest" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/remove-guest"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/remove-guest';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (500):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 229
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Server Error"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/ticket-codes/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/ticket-codes/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/ticket-codes/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 293
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Not Found",
    "errors": {
        "project_id": "Eintrag konnte nicht gefunden werden."
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/ticket_code/redeem" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/ticket_code/redeem"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/ticket_code/redeem';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (500):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 268
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Server Error"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/ticket_code/verify" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/ticket_code/verify"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/ticket_code/verify';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (500):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 267
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Server Error"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/ticket_code/tag" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/ticket_code/tag"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/ticket_code/tag';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (500):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 266
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Server Error"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/ticket_code/tag/revoke" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/ticket_code/tag/revoke"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/ticket_code/tag/revoke';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (500):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 265
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Server Error"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/hardtickets/activate" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"ticket_code\": \"WKD-A1B2C3D4\",
    \"firstname\": \"Anna\",
    \"lastname\": \"Schmidt\",
    \"email\": \"anna@example.com\",
    \"address\": \"Hauptstr. 12\",
    \"zip\": \"04109\",
    \"city\": \"Leipzig\"
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/hardtickets/activate"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "ticket_code": "WKD-A1B2C3D4",
    "firstname": "Anna",
    "lastname": "Schmidt",
    "email": "anna@example.com",
    "address": "Hauptstr. 12",
    "zip": "04109",
    "city": "Leipzig"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/hardtickets/activate';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'ticket_code' => 'WKD-A1B2C3D4',
            'firstname' => 'Anna',
            'lastname' => 'Schmidt',
            'email' => 'anna@example.com',
            'address' => 'Hauptstr. 12',
            'zip' => '04109',
            'city' => 'Leipzig',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (422):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 246
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "ticket_code": [
        "Die Auswahl zu ticket code ist ungültig."
    ]
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/hardtickets/check" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/hardtickets/check"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/hardtickets/check';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (500):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 245
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Server Error"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/meals/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/meals/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/meals/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 289
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Not Found",
    "errors": {
        "project_id": "Eintrag konnte nicht gefunden werden."
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/meals/architecto/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/meals/architecto/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/meals/architecto/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 288
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Not Found",
    "errors": {
        "project_id": "Eintrag konnte nicht gefunden werden."
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/meals/available" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/meals/available"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/meals/available';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (400):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 260
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "nfc_tag parameter is not provided. Please provide nfc_tag"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/meals/redeem" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/meals/redeem"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/meals/redeem';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (500):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 259
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Server Error"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/meals/redeem-multi" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"meal_order_id\": 123,
    \"amount\": 1
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/meals/redeem-multi"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "meal_order_id": 123,
    "amount": 1
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/meals/redeem-multi';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'meal_order_id' => 123,
            'amount' => 1.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (500):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 258
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Server Error"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/meals/redeem-adhoc" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"personTag\": \"04A3B2C1D2E3F4\",
    \"meal_id\": 7,
    \"amount\": 1
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/meals/redeem-adhoc"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "personTag": "04A3B2C1D2E3F4",
    "meal_id": 7,
    "amount": 1
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/meals/redeem-adhoc';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'personTag' => '04A3B2C1D2E3F4',
            'meal_id' => 7,
            'amount' => 1.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (422):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 257
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Die Auswahl zu person tag ist ungültig. (and 1 more error)",
    "errors": {
        "personTag": [
            "Die Auswahl zu person tag ist ungültig."
        ],
        "meal_id": [
            "Die Auswahl zu meal id ist ungültig."
        ]
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/meals/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/meals/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/meals/architecto';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (403):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 236
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "exception": "Signup Link is not valid",
    "message": "Signup Link is not valid."
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/meals" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/meals"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/meals';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (500):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 235
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Server Error"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/voucher/check" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/voucher/check"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/voucher/check';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (400):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 256
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "nfc_tag parameter is not provided. Please provide nfc_tag"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/voucher/check_type" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/voucher/check_type"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/voucher/check_type';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (400):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 255
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "nfc_tag parameter is not provided. Please provide nfc_tag",
    "success": false
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/voucher/redeem" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/voucher/redeem"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/voucher/redeem';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (400):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 254
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "person_id is not provided, neither is nfc_tag. Provide one of that"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/voucher/unredeem" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/voucher/unredeem"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/voucher/unredeem';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (500):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 253
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "not implemented, yet"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/voucher/stats" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/voucher/stats"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/voucher/stats';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (500):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 252
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "beneficiary_id is not provided, neither is beneficiary_tag. Please provide one of that."
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/form-definitions?project_id=1&per_page=25" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/form-definitions"
);

const params = {
    "project_id": "1",
    "per_page": "25",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/form-definitions';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'project_id' => '1',
            'per_page' => '25',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200, success):

[
    {
        "id": 1,
        "name": "Volunteer Registration",
        "project_id": 3,
        "to_type": "VOLUNTEER",
        "model": "App\\Person",
        "published": true,
        "published_from": null,
        "published_to": null,
        "url_shortname": "volunteer-reg",
        "created_at": "2025-01-15T10:00:00.000000Z",
        "updated_at": "2025-06-01T12:00:00.000000Z"
    }
]
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/form-definitions/1" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/form-definitions/1"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/form-definitions/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200, success):

{
    "id": 1,
    "name": "Volunteer Registration",
    "description": "Registration form for volunteers",
    "project_id": 3,
    "to_type": "VOLUNTEER",
    "model": "App\\Person",
    "data": {},
    "functions": [],
    "published": true,
    "published_from": null,
    "published_to": null,
    "unpublished_content": null,
    "html_intro": null,
    "success_response": null,
    "url_shortname": "volunteer-reg",
    "tab_label": null,
    "created_at": "2025-01-15T10:00:00.000000Z",
    "updated_at": "2025-06-01T12:00:00.000000Z"
}
 

Example response (404, not found):

{
    "message": "Form definition not found"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request PUT \
    "https://{instance}.festiware.eu/api/v1/form-definitions/1" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"Volunteer Registration 2026\",
    \"description\": \"Updated registration form\",
    \"html_intro\": {
        \"de\": \"<p>Willkommen<\\/p>\",
        \"en\": \"<p>Welcome<\\/p>\"
    },
    \"success_response\": {
        \"de\": \"Danke!\",
        \"en\": \"Thank you!\"
    },
    \"url_shortname\": \"volunteer-reg-2026\",
    \"tab_label\": {
        \"de\": \"Formular\",
        \"en\": \"Form\"
    },
    \"published\": true,
    \"published_from\": \"2026-04-01T00:00:00Z\",
    \"published_to\": \"2026-09-01T00:00:00Z\",
    \"unpublished_content\": \"This form is currently closed.\",
    \"data\": [],
    \"functions\": [
        []
    ]
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/form-definitions/1"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "Volunteer Registration 2026",
    "description": "Updated registration form",
    "html_intro": {
        "de": "<p>Willkommen<\/p>",
        "en": "<p>Welcome<\/p>"
    },
    "success_response": {
        "de": "Danke!",
        "en": "Thank you!"
    },
    "url_shortname": "volunteer-reg-2026",
    "tab_label": {
        "de": "Formular",
        "en": "Form"
    },
    "published": true,
    "published_from": "2026-04-01T00:00:00Z",
    "published_to": "2026-09-01T00:00:00Z",
    "unpublished_content": "This form is currently closed.",
    "data": [],
    "functions": [
        []
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/form-definitions/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'Volunteer Registration 2026',
            'description' => 'Updated registration form',
            'html_intro' => [
                'de' => '<p>Willkommen</p>',
                'en' => '<p>Welcome</p>',
            ],
            'success_response' => [
                'de' => 'Danke!',
                'en' => 'Thank you!',
            ],
            'url_shortname' => 'volunteer-reg-2026',
            'tab_label' => [
                'de' => 'Formular',
                'en' => 'Form',
            ],
            'published' => true,
            'published_from' => '2026-04-01T00:00:00Z',
            'published_to' => '2026-09-01T00:00:00Z',
            'unpublished_content' => 'This form is currently closed.',
            'data' => [],
            'functions' => [
                [],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200, success):

{
    "message": "Form definition updated",
    "formDefinition": {
        "id": 1,
        "name": "Volunteer Registration 2026",
        "published": true
    }
}
 

Example response (400, disallowed fields):

{
    "message": "Validation failed",
    "errors": {
        "disallowedFields": "The following fields are not allowed: project_id, to_type"
    }
}
 

Example response (404, not found):

{
    "message": "Form definition not found"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/form/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/form/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/form/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 244
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "errors.notExist"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/form/architecto/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/form/architecto/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/form/architecto/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (403):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 243
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "errors.link_not_valid"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/form" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/form"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/form';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (400):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 242
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "exception": "400 bad request",
    "message": "Bitte spezifizieren: form_def_id."
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/forms" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/forms"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/forms';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (400):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 241
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "exception": "400 bad request",
    "message": "Bitte spezifizieren: form_def_id."
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/form/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/form/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/form/architecto';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 240
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "errors.notExist"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/forms/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/forms/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/forms/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 239
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "errors.notExist"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/forms/update/architecto/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/forms/update/architecto/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/forms/update/architecto/architecto';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (403):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 238
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "errors.link_not_valid"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/forms/show-available/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/forms/show-available/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/forms/show-available/architecto';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (403):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 237
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "errors.link_not_valid"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/resend-email" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/resend-email"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/resend-email';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 234
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

[]
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/files/upload" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/files/upload"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/files/upload';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (400):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 228
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Upload needs to be a file!"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/files/delete" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"id\": \"architecto\"
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/files/delete"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": "architecto"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/files/delete';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'id' => 'architecto',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 227
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "No query results for model [App\\File] architecto"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/gdpr-info" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/gdpr-info"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/gdpr-info';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 226
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "company": {
        "name": "Stiftung ION",
        "person_name": "Moritz Puschke",
        "address_1": "Winklerstr. 13",
        "zip": "90403",
        "place": "Nürnberg",
        "contact_phone": "0911-2144466",
        "contact_email": "info@musikfest-ion.de"
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/terms-info" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/terms-info"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/terms-info';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 225
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "company": {
        "name": "Stiftung ION",
        "person_name": "Moritz Puschke",
        "address_1": "Winklerstr. 13",
        "zip": "90403",
        "place": "Nürnberg",
        "contact_phone": "0911-2144466",
        "contact_email": "info@musikfest-ion.de",
        "business_reg_place": null,
        "business_legal_venue": null,
        "terms_individual": null,
        "vat_reg_no": "DE133550742",
        "business_id": null
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/forms/request_token/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/forms/request_token/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/forms/request_token/architecto';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (403):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 224
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Invalid Signup Link"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/areas/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/areas/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/areas/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 298
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Not Found",
    "errors": {
        "project_id": "Eintrag konnte nicht gefunden werden."
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/area/architecto/events" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/area/architecto/events"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/area/architecto/events';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (500):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 297
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Server Error"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/event_plans/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/event_plans/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/event_plans/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 296
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Not Found",
    "errors": {
        "project_id": "Eintrag konnte nicht gefunden werden."
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/event_plan/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/event_plan/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/event_plan/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (500):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 295
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Server Error"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/event_types/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/event_types/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/event_types/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 294
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Not Found",
    "errors": {
        "project_id": "Eintrag konnte nicht gefunden werden."
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/supplies/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/supplies/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/supplies/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (500):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 264
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Server Error"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/supply/architecto/items" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/supply/architecto/items"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/supply/architecto/items';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 263
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "No query results for model [App\\Modules\\Supply\\Models\\Supply] architecto"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/supply/item/tracking" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"supply_order_id\": 42,
    \"person_id\": \"550e8400-e29b-41d4-a716-446655440000\",
    \"person_tag_number\": \"04A3B2C1D2E3F4\",
    \"supply_item_tag_number\": \"SUP001\",
    \"supply_item_tag_numbers\": [
        \"architecto\"
    ],
    \"supply_item_id\": 17,
    \"event_type\": \"issued\",
    \"area_id\": 3,
    \"stock_location\": \"Warehouse A, Shelf 3\",
    \"geolocation\": \"51.3397,12.3731\",
    \"w3w\": \"filled.count.soap\",
    \"annotations\": \"Slight damage on left handle\",
    \"image_url\": \"https:\\/\\/storage.example.com\\/tracking\\/img001.jpg\",
    \"tracked_at\": \"2026-07-15T10:30:00+02:00\"
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/supply/item/tracking"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "supply_order_id": 42,
    "person_id": "550e8400-e29b-41d4-a716-446655440000",
    "person_tag_number": "04A3B2C1D2E3F4",
    "supply_item_tag_number": "SUP001",
    "supply_item_tag_numbers": [
        "architecto"
    ],
    "supply_item_id": 17,
    "event_type": "issued",
    "area_id": 3,
    "stock_location": "Warehouse A, Shelf 3",
    "geolocation": "51.3397,12.3731",
    "w3w": "filled.count.soap",
    "annotations": "Slight damage on left handle",
    "image_url": "https:\/\/storage.example.com\/tracking\/img001.jpg",
    "tracked_at": "2026-07-15T10:30:00+02:00"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/supply/item/tracking';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'supply_order_id' => 42,
            'person_id' => '550e8400-e29b-41d4-a716-446655440000',
            'person_tag_number' => '04A3B2C1D2E3F4',
            'supply_item_tag_number' => 'SUP001',
            'supply_item_tag_numbers' => [
                'architecto',
            ],
            'supply_item_id' => 17,
            'event_type' => 'issued',
            'area_id' => 3,
            'stock_location' => 'Warehouse A, Shelf 3',
            'geolocation' => '51.3397,12.3731',
            'w3w' => 'filled.count.soap',
            'annotations' => 'Slight damage on left handle',
            'image_url' => 'https://storage.example.com/tracking/img001.jpg',
            'tracked_at' => '2026-07-15T10:30:00+02:00',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (422):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 262
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "person_id": [
        "Die Auswahl zu person id ist ungültig."
    ],
    "person_tag_number": [
        "Die Auswahl zu person tag number ist ungültig."
    ],
    "supply_item_tag_number": [
        "Die Auswahl zu supply item tag number ist ungültig."
    ],
    "supply_item_id": [
        "Die Auswahl zu supply item id ist ungültig."
    ],
    "area_id": [
        "Die Auswahl zu area id ist ungültig."
    ],
    "supply_item_tag_numbers.0": [
        "Die Auswahl zu supply_item_tag_numbers.0 ist ungültig."
    ]
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/supply/item/architecto/tracking" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/supply/item/architecto/tracking"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/supply/item/architecto/tracking';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (500):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 261
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Server Error"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/ticket-types/architecto?project_id=5" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/ticket-types/architecto"
);

const params = {
    "project_id": "5",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/ticket-types/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'project_id' => '5',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200, Success):

[
    {
        "id": 161,
        "name": "Shuttle Berlin",
        "shortname": "BFST",
        "issue": 100,
        "project_id": 5,
        "offers": [],
        "options": []
    }
]
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/ticket-types/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"Shuttle Berlin\",
    \"shortname\": \"BFST\",
    \"description\": \"Berlin Ostbahnhof to Festival\",
    \"issue\": 100,
    \"available_in_backend\": true,
    \"project_id\": 5
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/ticket-types/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "Shuttle Berlin",
    "shortname": "BFST",
    "description": "Berlin Ostbahnhof to Festival",
    "issue": 100,
    "available_in_backend": true,
    "project_id": 5
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/ticket-types/architecto';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'Shuttle Berlin',
            'shortname' => 'BFST',
            'description' => 'Berlin Ostbahnhof to Festival',
            'issue' => 100,
            'available_in_backend' => true,
            'project_id' => 5,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (201, Created):

{
    "id": 161,
    "name": "Shuttle Berlin",
    "shortname": "BFST",
    "issue": 100,
    "project_id": 5,
    "offers": [],
    "options": []
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/ticket-types/architecto/161" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/ticket-types/architecto/161"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/ticket-types/architecto/161';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200, Success):

{
    "id": 161,
    "name": "Shuttle Berlin",
    "shortname": "BFST",
    "offers": [
        {
            "id": 1,
            "price": 39,
            "tax": 0.08
        }
    ],
    "options": [
        {
            "id": 1,
            "name": "Fr 09:00",
            "issue": 49
        }
    ]
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request PUT \
    "https://{instance}.festiware.eu/api/v1/ticket-types/architecto/161" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"Shuttle Berlin (Updated)\",
    \"shortname\": \"BFST\",
    \"description\": \"Eius et animi quos velit et.\",
    \"issue\": 200,
    \"available_in_backend\": false
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/ticket-types/architecto/161"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "Shuttle Berlin (Updated)",
    "shortname": "BFST",
    "description": "Eius et animi quos velit et.",
    "issue": 200,
    "available_in_backend": false
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/ticket-types/architecto/161';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'Shuttle Berlin (Updated)',
            'shortname' => 'BFST',
            'description' => 'Eius et animi quos velit et.',
            'issue' => 200,
            'available_in_backend' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200, Updated):

{
    "id": 161,
    "name": "Shuttle Berlin (Updated)",
    "shortname": "BFST",
    "issue": 200
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request DELETE \
    "https://{instance}.festiware.eu/api/v1/ticket-types/architecto/161" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/ticket-types/architecto/161"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/ticket-types/architecto/161';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200, Deleted):

{
    "success": true
}
 

Example response (409, Has offers):

{
    "error": "Cannot delete: ticket type has offers"
}
 

Example response (409, Has codes):

{
    "error": "Cannot delete: ticket type has ticket codes"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/ticket-types/architecto/161/options/bulk" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"options\": [
        \"architecto\"
    ]
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/ticket-types/architecto/161/options/bulk"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "options": [
        "architecto"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/ticket-types/architecto/161/options/bulk';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'options' => [
                'architecto',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (201, Created):

{
    "count": 10,
    "options": [
        {
            "id": 1,
            "name": "Fr 09.07 — 08:00",
            "issue": 49,
            "active": true
        }
    ]
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request DELETE \
    "https://{instance}.festiware.eu/api/v1/ticket-types/architecto/161/cascade" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/ticket-types/architecto/161/cascade"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/ticket-types/architecto/161/cascade';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200, Deleted):

{
    "success": true,
    "offers_deleted": 2,
    "options_deleted": 31
}
 

Example response (409, Has codes):

{
    "error": "Cannot delete: ticket type has ticket codes"
}
 

Example response (409, Has orders):

{
    "error": "Cannot delete: offers have existing orders"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/offer-categories/architecto?project_id=5" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/offer-categories/architecto"
);

const params = {
    "project_id": "5",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/offer-categories/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'project_id' => '5',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200, Success):

[
    {
        "id": 454,
        "name": "Outbound",
        "shortname": "out",
        "project_id": 5,
        "offers": []
    }
]
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/offer-categories/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"Outbound\",
    \"shortname\": \"out\",
    \"description\": \"Eius et animi quos velit et.\",
    \"project_id\": 5
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/offer-categories/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "Outbound",
    "shortname": "out",
    "description": "Eius et animi quos velit et.",
    "project_id": 5
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/offer-categories/architecto';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'Outbound',
            'shortname' => 'out',
            'description' => 'Eius et animi quos velit et.',
            'project_id' => 5,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (201, Created):

{
    "id": 454,
    "name": "Outbound",
    "shortname": "out",
    "project_id": 5
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/offer-categories/architecto/454" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/offer-categories/architecto/454"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/offer-categories/architecto/454';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200, Success):

{
    "id": 454,
    "name": "Outbound",
    "shortname": "out",
    "offers": [
        {
            "id": 1,
            "shortname": "Early Bird"
        }
    ]
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request PUT \
    "https://{instance}.festiware.eu/api/v1/offer-categories/architecto/454" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"Outbound (Renamed)\",
    \"shortname\": \"outbound\",
    \"description\": \"Eius et animi quos velit et.\"
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/offer-categories/architecto/454"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "Outbound (Renamed)",
    "shortname": "outbound",
    "description": "Eius et animi quos velit et."
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/offer-categories/architecto/454';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'Outbound (Renamed)',
            'shortname' => 'outbound',
            'description' => 'Eius et animi quos velit et.',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200, Updated):

{
    "id": 454,
    "name": "Outbound (Renamed)",
    "shortname": "outbound"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request DELETE \
    "https://{instance}.festiware.eu/api/v1/offer-categories/architecto/454" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/offer-categories/architecto/454"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/offer-categories/architecto/454';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200, Deleted):

{
    "success": true
}
 

Example response (409, Has offers):

{
    "error": "Cannot delete: category has offers"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/offerable-options/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/offerable-options/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/offerable-options/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 287
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Not Found",
    "errors": {
        "project_id": "Eintrag konnte nicht gefunden werden."
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/offerable-options/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"offerable_id\": 1,
    \"offerable_type\": \"App\\\\TicketType\",
    \"name\": \"Camping Add-On\",
    \"description\": \"Includes camping ground access\",
    \"issue\": 0,
    \"active\": true,
    \"valid_from\": \"2026-06-01\",
    \"valid_to\": \"2026-08-31\"
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/offerable-options/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "offerable_id": 1,
    "offerable_type": "App\\TicketType",
    "name": "Camping Add-On",
    "description": "Includes camping ground access",
    "issue": 0,
    "active": true,
    "valid_from": "2026-06-01",
    "valid_to": "2026-08-31"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/offerable-options/architecto';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'offerable_id' => 1,
            'offerable_type' => 'App\\TicketType',
            'name' => 'Camping Add-On',
            'description' => 'Includes camping ground access',
            'issue' => 0,
            'active' => true,
            'valid_from' => '2026-06-01',
            'valid_to' => '2026-08-31',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 286
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Not Found",
    "errors": {
        "project_id": "Eintrag konnte nicht gefunden werden."
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/offerable-options/architecto/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/offerable-options/architecto/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/offerable-options/architecto/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 285
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Not Found",
    "errors": {
        "project_id": "Eintrag konnte nicht gefunden werden."
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request PUT \
    "https://{instance}.festiware.eu/api/v1/offerable-options/architecto/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"Camping Add-On\",
    \"description\": \"Includes camping ground access\",
    \"issue\": 0,
    \"active\": true,
    \"valid_from\": \"2026-06-01\",
    \"valid_to\": \"2026-08-31\"
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/offerable-options/architecto/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "Camping Add-On",
    "description": "Includes camping ground access",
    "issue": 0,
    "active": true,
    "valid_from": "2026-06-01",
    "valid_to": "2026-08-31"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/offerable-options/architecto/architecto';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'Camping Add-On',
            'description' => 'Includes camping ground access',
            'issue' => 0,
            'active' => true,
            'valid_from' => '2026-06-01',
            'valid_to' => '2026-08-31',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 284
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Not Found",
    "errors": {
        "project_id": "Eintrag konnte nicht gefunden werden."
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request DELETE \
    "https://{instance}.festiware.eu/api/v1/offerable-options/architecto/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/offerable-options/architecto/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/offerable-options/architecto/architecto';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 283
access-control-allow-origin: *
access-control-expose-headers: Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma
 

{
    "message": "Not Found",
    "errors": {
        "project_id": "Eintrag konnte nicht gefunden werden."
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/offers/setup-project" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"project_id\": 5,
    \"ticket_types\": [
        {
            \"offer_category\": {
                \"id\": 454,
                \"name\": \"Outbound\",
                \"shortname\": \"out\"
            },
            \"offer\": {
                \"price\": \"39.00\",
                \"tax\": \"0.08\",
                \"tax_rules\": [
                    \"architecto\"
                ],
                \"shortname\": \"Shuttle Hin\",
                \"max_order_amount\": 8,
                \"published\": true
            }
        }
    ]
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/offers/setup-project"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "project_id": 5,
    "ticket_types": [
        {
            "offer_category": {
                "id": 454,
                "name": "Outbound",
                "shortname": "out"
            },
            "offer": {
                "price": "39.00",
                "tax": "0.08",
                "tax_rules": [
                    "architecto"
                ],
                "shortname": "Shuttle Hin",
                "max_order_amount": 8,
                "published": true
            }
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/offers/setup-project';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'project_id' => 5,
            'ticket_types' => [
                [
                    'offer_category' => [
                        'id' => 454,
                        'name' => 'Outbound',
                        'shortname' => 'out',
                    ],
                    'offer' => [
                        'price' => '39.00',
                        'tax' => '0.08',
                        'tax_rules' => [
                            'architecto',
                        ],
                        'shortname' => 'Shuttle Hin',
                        'max_order_amount' => 8,
                        'published' => true,
                    ],
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (201, Created):

[
    {
        "ticket_type": {
            "id": 161
        },
        "offer_category": {
            "id": 454
        },
        "offer": {
            "id": 1
        },
        "options_count": 10,
        "options": []
    }
]
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request POST \
    "https://{instance}.festiware.eu/api/v1/offers/architecto" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"offerable_id\": 161,
    \"offerable_type\": \"App\\\\TicketType\",
    \"price\": \"39.00\",
    \"tax\": \"0.08\",
    \"tax_rules\": [
        {
            \"attributes\": {
                \"label\": \"Tax Germany\",
                \"percent\": \"0.509\",
                \"rate\": \"0.08\"
            }
        }
    ],
    \"issue\": 100,
    \"shortname\": \"Early Bird Ticket\",
    \"description\": \"Eius et animi quos velit et.\",
    \"offer_category_id\": 454,
    \"email_product\": false,
    \"max_order_amount\": 4,
    \"published_from\": \"2026-06-01\",
    \"published_to\": \"2026-07-15\",
    \"available_from\": \"2026-07-01\",
    \"available_to\": \"2026-07-10\",
    \"hidden_link\": \"architecto\"
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/offers/architecto"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "offerable_id": 161,
    "offerable_type": "App\\TicketType",
    "price": "39.00",
    "tax": "0.08",
    "tax_rules": [
        {
            "attributes": {
                "label": "Tax Germany",
                "percent": "0.509",
                "rate": "0.08"
            }
        }
    ],
    "issue": 100,
    "shortname": "Early Bird Ticket",
    "description": "Eius et animi quos velit et.",
    "offer_category_id": 454,
    "email_product": false,
    "max_order_amount": 4,
    "published_from": "2026-06-01",
    "published_to": "2026-07-15",
    "available_from": "2026-07-01",
    "available_to": "2026-07-10",
    "hidden_link": "architecto"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/offers/architecto';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'offerable_id' => 161,
            'offerable_type' => 'App\\TicketType',
            'price' => '39.00',
            'tax' => '0.08',
            'tax_rules' => [
                [
                    'attributes' => [
                        'label' => 'Tax Germany',
                        'percent' => '0.509',
                        'rate' => '0.08',
                    ],
                ],
            ],
            'issue' => 100,
            'shortname' => 'Early Bird Ticket',
            'description' => 'Eius et animi quos velit et.',
            'offer_category_id' => 454,
            'email_product' => false,
            'max_order_amount' => 4,
            'published_from' => '2026-06-01',
            'published_to' => '2026-07-15',
            'available_from' => '2026-07-01',
            'available_to' => '2026-07-10',
            'hidden_link' => 'architecto',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (201, Created):

{
    "id": 1,
    "price": 39,
    "tax": 0.08,
    "shortname": "Early Bird Ticket",
    "project_id": 5
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request GET \
    --get "https://{instance}.festiware.eu/api/v1/offers/architecto/1" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/offers/architecto/1"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/offers/architecto/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200, Success):

{
    "id": 1,
    "price": 39,
    "tax": 0.08,
    "shortname": "Early Bird",
    "offerable": {
        "id": 161,
        "name": "Shuttle"
    },
    "offer_category": {
        "id": 454,
        "name": "Outbound"
    }
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.

Example request:

curl --request PUT \
    "https://{instance}.festiware.eu/api/v1/offers/architecto/1" \
    --header "Authorization: Bearer {ACCESS_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"price\": \"45.00\",
    \"tax\": \"0.19\",
    \"tax_rules\": [
        {
            \"layout\": \"rule\",
            \"key\": \"abc123\",
            \"attributes\": {
                \"label\": \"Reduced VAT\",
                \"percent\": 1,
                \"rate\": 0.07
            }
        }
    ],
    \"issue\": 0,
    \"shortname\": \"Late Bird Ticket\",
    \"description\": \"Eius et animi quos velit et.\",
    \"offer_category_id\": 5,
    \"email_product\": false,
    \"max_order_amount\": 4,
    \"published_from\": \"2026-06-01\",
    \"published_to\": \"2026-07-15\",
    \"available_from\": \"2026-07-01\",
    \"available_to\": \"2026-07-10\",
    \"hidden_link\": \"architecto\"
}"

const url = new URL(
    "https://{instance}.festiware.eu/api/v1/offers/architecto/1"
);

const headers = {
    "Authorization": "Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "price": "45.00",
    "tax": "0.19",
    "tax_rules": [
        {
            "layout": "rule",
            "key": "abc123",
            "attributes": {
                "label": "Reduced VAT",
                "percent": 1,
                "rate": 0.07
            }
        }
    ],
    "issue": 0,
    "shortname": "Late Bird Ticket",
    "description": "Eius et animi quos velit et.",
    "offer_category_id": 5,
    "email_product": false,
    "max_order_amount": 4,
    "published_from": "2026-06-01",
    "published_to": "2026-07-15",
    "available_from": "2026-07-01",
    "available_to": "2026-07-10",
    "hidden_link": "architecto"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'https://{instance}.festiware.eu/api/v1/offers/architecto/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {ACCESS_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'price' => '45.00',
            'tax' => '0.19',
            'tax_rules' => [
                [
                    'layout' => 'rule',
                    'key' => 'abc123',
                    'attributes' => [
                        'label' => 'Reduced VAT',
                        'percent' => 1.0,
                        'rate' => 0.07,
                    ],
                ],
            ],
            'issue' => 0,
            'shortname' => 'Late Bird Ticket',
            'description' => 'Eius et animi quos velit et.',
            'offer_category_id' => 5,
            'email_product' => false,
            'max_order_amount' => 4,
            'published_from' => '2026-06-01',
            'published_to' => '2026-07-15',
            'available_from' => '2026-07-01',
            'available_to' => '2026-07-10',
            'hidden_link' => 'architecto',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200, Updated):

{
    "id": 1,
    "price": 45,
    "tax": 0.19,
    "shortname": "Late Bird Ticket"
}
 

Received response:

Request failed with error:

Tip: Check that you're properly connected to the network.
If you're a maintainer of ths API, verify that your API is running and you've enabled CORS.
You can check the Dev Tools console for debugging information.