diff --git a/lnbits/extensions/events/views_api.py b/lnbits/extensions/events/views_api.py
index fddbf2a45..16603a0f4 100644
--- a/lnbits/extensions/events/views_api.py
+++ b/lnbits/extensions/events/views_api.py
@@ -4,6 +4,7 @@ from http import HTTPStatus
 from lnbits.core.crud import get_user, get_wallet
 from lnbits.core.services import create_invoice, check_invoice_status
 from lnbits.decorators import api_check_wallet_key, api_validate_post_request
+from fastapi.encoders import jsonable_encoder
 
 from . import events_ext
 from .crud import (
@@ -26,7 +27,7 @@ from .crud import (
 
 
 
-@events_ext.route("/api/v1/events", methods=["GET"])
+@events_ext.get("/api/v1/events")
 @api_check_wallet_key("invoice")
 async def api_events():
     wallet_ids = [g.wallet.id]
@@ -35,7 +36,7 @@ async def api_events():
         wallet_ids = (await get_user(g.wallet.user)).wallet_ids
 
     return (
-        jsonify([event._asdict() for event in await get_events(wallet_ids)]),
+        [event._asdict() for event in await get_events(wallet_ids)],
         HTTPStatus.OK,
     )
 
@@ -49,46 +50,34 @@ class CreateData(BaseModel):
     amount_tickets:  int = Query(..., ge=0),
     price_per_ticket:  int = Query(..., ge=0),
 
-@events_ext.route("/api/v1/events", methods=["POST"])
-@events_ext.route("/api/v1/events/<event_id>", methods=["PUT"])
+@events_ext.post("/api/v1/events")
+@events_ext.put("/api/v1/events/<event_id>")
 @api_check_wallet_key("invoice")
-@api_validate_post_request(
-    schema={
-        "wallet": {"type": "string", "empty": False, "required": True},
-        "name": {"type": "string", "empty": False, "required": True},
-        "info": {"type": "string", "min": 0, "required": True},
-        "closing_date": {"type": "string", "empty": False, "required": True},
-        "event_start_date": {"type": "string", "empty": False, "required": True},
-        "event_end_date": {"type": "string", "empty": False, "required": True},
-        "amount_tickets": {"type": "integer", "min": 0, "required": True},
-        "price_per_ticket": {"type": "integer", "min": 0, "required": True},
-    }
-)
 async def api_event_create(data: CreateData, event_id=None):
     if event_id:
         event = await get_event(event_id)
         if not event:
-            return jsonify({"message": "Form does not exist."}), HTTPStatus.NOT_FOUND
+            return jsonable_encoder({"message": "Form does not exist."}), HTTPStatus.NOT_FOUND
 
         if event.wallet != g.wallet.id:
-            return jsonify({"message": "Not your event."}), HTTPStatus.FORBIDDEN
+            return jsonable_encoder({"message": "Not your event."}), HTTPStatus.FORBIDDEN
 
-        event = await update_event(event_id, **g.data)
+        event = await update_event(event_id, **data)
     else:
-        event = await create_event(**g.data)
+        event = await create_event(**data)
 
-    return jsonify(event._asdict()), HTTPStatus.CREATED
+    return event._asdict(), HTTPStatus.CREATED
 
 
-@events_ext.route("/api/v1/events/<event_id>", methods=["DELETE"])
+@events_ext.delete("/api/v1/events/<event_id>")
 @api_check_wallet_key("invoice")
 async def api_form_delete(event_id):
     event = await get_event(event_id)
     if not event:
-        return jsonify({"message": "Event does not exist."}), HTTPStatus.NOT_FOUND
+        return jsonable_encoder({"message": "Event does not exist."}), HTTPStatus.NOT_FOUND
 
     if event.wallet != g.wallet.id:
-        return jsonify({"message": "Not your event."}), HTTPStatus.FORBIDDEN
+        return jsonable_encoder({"message": "Not your event."}), HTTPStatus.FORBIDDEN
 
     await delete_event(event_id)
     return "", HTTPStatus.NO_CONTENT
@@ -97,7 +86,7 @@ async def api_form_delete(event_id):
 #########Tickets##########
 
 
-@events_ext.route("/api/v1/tickets", methods=["GET"])
+@events_ext.get("/api/v1/tickets")
 @api_check_wallet_key("invoice")
 async def api_tickets():
     wallet_ids = [g.wallet.id]
@@ -106,22 +95,19 @@ async def api_tickets():
         wallet_ids = (await get_user(g.wallet.user)).wallet_ids
 
     return (
-        jsonify([ticket._asdict() for ticket in await get_tickets(wallet_ids)]),
+        [ticket._asdict() for ticket in await get_tickets(wallet_ids)],
         HTTPStatus.OK,
     )
 
+class CreateTicketData(BaseModel):
+    name:  str = Query(...),
+    email:  str
 
-@events_ext.route("/api/v1/tickets/<event_id>/<sats>", methods=["POST"])
-@api_validate_post_request(
-    schema={
-        "name": {"type": "string", "empty": False, "required": True},
-        "email": {"type": "string", "empty": False, "required": True},
-    }
-)
-async def api_ticket_make_ticket(event_id, sats):
+@events_ext.post("/api/v1/tickets/<event_id>/<sats>")
+async def api_ticket_make_ticket(data: CreateTicketData, event_id, sats):
     event = await get_event(event_id)
     if not event:
-        return jsonify({"message": "Event does not exist."}), HTTPStatus.NOT_FOUND
+        return jsonable_encoder({"message": "Event does not exist."}), HTTPStatus.NOT_FOUND
     try:
         payment_hash, payment_request = await create_invoice(
             wallet_id=event.wallet,
@@ -133,19 +119,19 @@ async def api_ticket_make_ticket(event_id, sats):
         return jsonify({"message": str(e)}), HTTPStatus.INTERNAL_SERVER_ERROR
 
     ticket = await create_ticket(
-        payment_hash=payment_hash, wallet=event.wallet, event=event_id, **g.data
+        payment_hash=payment_hash, wallet=event.wallet, event=event_id, **data
     )
 
     if not ticket:
-        return jsonify({"message": "Event could not be fetched."}), HTTPStatus.NOT_FOUND
+        return jsonable_encoder({"message": "Event could not be fetched."}), HTTPStatus.NOT_FOUND
 
     return (
-        jsonify({"payment_hash": payment_hash, "payment_request": payment_request}),
+        jsonable_encoder({"payment_hash": payment_hash, "payment_request": payment_request}),
         HTTPStatus.OK,
     )
 
 
-@events_ext.route("/api/v1/tickets/<payment_hash>", methods=["GET"])
+@events_ext.get("/api/v1/tickets/<payment_hash>")
 async def api_ticket_send_ticket(payment_hash):
     ticket = await get_ticket(payment_hash)
 
@@ -153,7 +139,7 @@ async def api_ticket_send_ticket(payment_hash):
         status = await check_invoice_status(ticket.wallet, payment_hash)
         is_paid = not status.pending
     except Exception:
-        return jsonify({"message": "Not paid."}), HTTPStatus.NOT_FOUND
+        return jsonable_encoder({"message": "Not paid."}), HTTPStatus.NOT_FOUND
 
     if is_paid:
         wallet = await get_wallet(ticket.wallet)
@@ -161,21 +147,21 @@ async def api_ticket_send_ticket(payment_hash):
         await payment.set_pending(False)
         ticket = await set_ticket_paid(payment_hash=payment_hash)
 
-        return jsonify({"paid": True, "ticket_id": ticket.id}), HTTPStatus.OK
+        return jsonable_encoder({"paid": True, "ticket_id": ticket.id}), HTTPStatus.OK
 
-    return jsonify({"paid": False}), HTTPStatus.OK
+    return jsonable_encoder({"paid": False}), HTTPStatus.OK
 
 
-@events_ext.route("/api/v1/tickets/<ticket_id>", methods=["DELETE"])
+@events_ext.delete("/api/v1/tickets/<ticket_id>")
 @api_check_wallet_key("invoice")
 async def api_ticket_delete(ticket_id):
     ticket = await get_ticket(ticket_id)
 
     if not ticket:
-        return jsonify({"message": "Ticket does not exist."}), HTTPStatus.NOT_FOUND
+        return jsonable_encoder({"message": "Ticket does not exist."}), HTTPStatus.NOT_FOUND
 
     if ticket.wallet != g.wallet.id:
-        return jsonify({"message": "Not your ticket."}), HTTPStatus.FORBIDDEN
+        return jsonable_encoder({"message": "Not your ticket."}), HTTPStatus.FORBIDDEN
 
     await delete_ticket(ticket_id)
     return "", HTTPStatus.NO_CONTENT
@@ -184,34 +170,26 @@ async def api_ticket_delete(ticket_id):
 # Event Tickets
 
 
-@events_ext.route("/api/v1/eventtickets/<wallet_id>/<event_id>", methods=["GET"])
+@events_ext.get("/api/v1/eventtickets/<wallet_id>/<event_id>")
 async def api_event_tickets(wallet_id, event_id):
-    return (
-        jsonify(
-            [
-                ticket._asdict()
-                for ticket in await get_event_tickets(
-                    wallet_id=wallet_id, event_id=event_id
-                )
-            ]
-        ),
+    return ([ticket._asdict() for ticket in await get_event_tickets(wallet_id=wallet_id, event_id=event_id)],
         HTTPStatus.OK,
     )
 
 
-@events_ext.route("/api/v1/register/ticket/<ticket_id>", methods=["GET"])
+@events_ext.get("/api/v1/register/ticket/<ticket_id>")
 async def api_event_register_ticket(ticket_id):
     ticket = await get_ticket(ticket_id)
     if not ticket:
-        return jsonify({"message": "Ticket does not exist."}), HTTPStatus.FORBIDDEN
+        return jsonable_encoder({"message": "Ticket does not exist."}), HTTPStatus.FORBIDDEN
 
     if not ticket.paid:
-        return jsonify({"message": "Ticket not paid for."}), HTTPStatus.FORBIDDEN
+        return jsonable_encoder({"message": "Ticket not paid for."}), HTTPStatus.FORBIDDEN
 
     if ticket.registered == True:
-        return jsonify({"message": "Ticket already registered"}), HTTPStatus.FORBIDDEN
+        return jsonable_encoder({"message": "Ticket already registered"}), HTTPStatus.FORBIDDEN
 
     return (
-        jsonify([ticket._asdict() for ticket in await reg_ticket(ticket_id)]),
+        [ticket._asdict() for ticket in await reg_ticket(ticket_id)],
         HTTPStatus.OK,
     )