diff --git a/.env.example b/.env.example
index 3fd316e5..6b29b9a8 100644
--- a/.env.example
+++ b/.env.example
@@ -18,6 +18,9 @@ OSEM_API_URL="https://api.opensensemap.org/"
 DIRECTUS_URL="https://coelho.opensensemap.org"
 SENSORWIKI_API_URL="https://api.sensors.wiki/"
 
+MQTT_SERVICE_URL="http://localhost:3001"
+MQTT_SERVICE_KEY="dev-service-key-change-in-production"
+
 MYBADGES_API_URL = "https://api.v2.mybadges.org/"
 MYBADGES_URL = "https://mybadges.org/"
 MYBADGES_SERVERADMIN_USERNAME = ""
diff --git a/app/components/device/new/advanced-info.tsx b/app/components/device/new/advanced-info.tsx
index 240c8f20..6284f79e 100644
--- a/app/components/device/new/advanced-info.tsx
+++ b/app/components/device/new/advanced-info.tsx
@@ -1,246 +1,130 @@
-import { useFormContext } from 'react-hook-form'
-import {
-	Card,
-	CardContent,
-	CardDescription,
-	CardHeader,
-	CardTitle,
-} from '~/components/ui/card'
-import { Input } from '~/components/ui/input'
-import { Label } from '~/components/ui/label'
-import {
-	Select,
-	SelectContent,
-	SelectItem,
-	SelectTrigger,
-	SelectValue,
-} from '~/components/ui/select'
-import { Switch } from '~/components/ui/switch'
-import { Textarea } from '~/components/ui/textarea'
+import Form from "@rjsf/core";
+import validator from "@rjsf/validator-ajv8";
+import { useEffect, useState } from "react";
+import { useFormContext } from "react-hook-form";
+import { CheckboxWidget } from "~/components/rjsf/checkboxWidget";
+import { FieldTemplate } from "~/components/rjsf/fieldTemplate";
+import { BaseInputTemplate } from "~/components/rjsf/inputTemplate";
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "~/components/ui/card";
+import { Label } from "~/components/ui/label";
+import { Switch } from "~/components/ui/switch";
+import { type IntegrationMetadata } from "~/routes/api.integrations";
 
 export function AdvancedStep() {
-	const { register, setValue, watch, resetField } = useFormContext()
-
-	// Watch field states
-	const isMqttEnabled = watch('mqttEnabled') || false
-	const isTtnEnabled = watch('ttnEnabled') || false
-
-	// Clear corresponding fields when disabling
-	const handleMqttToggle = (checked: boolean) => {
-		setValue('mqttEnabled', checked)
-		if (!checked) {
-			resetField('url')
-			resetField('topic')
-			resetField('messageFormat')
-			resetField('decodeOptions')
-			resetField('connectionOptions')
-		}
-	}
-
-	const handleTtnToggle = (checked: boolean) => {
-		setValue('ttnEnabled', checked)
-		if (!checked) {
-			resetField('dev_id')
-			resetField('app_id')
-			resetField('profile')
-			resetField('decodeOptions')
-			resetField('port')
-		}
-	}
-
-	const handleInputChange = (
-		event: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>,
-	) => {
-		const { name, value } = event.target
-		setValue(name, value)
-	}
-
-	const handleSelectChange = (field: string, value: string) => {
-		setValue(field, value)
-	}
-
-	return (
-		<>
-			{/* MQTT Configuration */}
-			<Card className="w-full">
-				<CardHeader>
-					<CardTitle>MQTT Configuration</CardTitle>
-					<CardDescription>
-						Configure your MQTT settings for data streaming
-					</CardDescription>
-				</CardHeader>
-				<CardContent>
-					<div className="flex items-center justify-between space-x-2">
-						<Label htmlFor="mqttEnabled" className="text-base font-semibold">
-							Enable MQTT
-						</Label>
-						<Switch
-							disabled
-							id="mqttEnabled"
-							checked={isMqttEnabled}
-							onCheckedChange={handleMqttToggle}
-						/>
-					</div>
-
-					{isMqttEnabled && (
-						<div className="space-y-4">
-							<div className="space-y-2">
-								<Label htmlFor="mqtt-url">MQTT URL</Label>
-								<Input
-									id="mqtt-url"
-									placeholder="mqtt://example.com:1883"
-									{...register('url')}
-									onChange={handleInputChange}
-								/>
-							</div>
-
-							<div className="space-y-2">
-								<Label htmlFor="mqtt-topic">MQTT Topic</Label>
-								<Input
-									id="mqtt-topic"
-									placeholder="my/mqtt/topic"
-									{...register('topic')}
-									onChange={handleInputChange}
-								/>
-							</div>
-
-							<div className="space-y-2">
-								<Label htmlFor="mqtt-message-format">Message Format</Label>
-								<Select
-									onValueChange={(value) =>
-										handleSelectChange('messageFormat', value)
-									}
-									defaultValue={watch('messageFormat')}
-								>
-									<SelectTrigger id="mqtt-message-format">
-										<SelectValue placeholder="Select a message format" />
-									</SelectTrigger>
-									<SelectContent>
-										<SelectItem value="json">JSON</SelectItem>
-										<SelectItem value="csv">CSV</SelectItem>
-									</SelectContent>
-								</Select>
-							</div>
-
-							<div className="space-y-2">
-								<Label htmlFor="mqtt-decode-options">Decode Options</Label>
-								<Textarea
-									id="mqtt-decode-options"
-									placeholder="Enter decode options as JSON"
-									className="resize-none"
-									{...register('decodeOptions')}
-									onChange={handleInputChange}
-								/>
-							</div>
-
-							<div className="space-y-2">
-								<Label htmlFor="mqtt-connection-options">
-									Connection Options
-								</Label>
-								<Textarea
-									id="mqtt-connection-options"
-									placeholder="Enter connection options as JSON"
-									className="resize-none"
-									{...register('connectionOptions')}
-									onChange={handleInputChange}
-								/>
-							</div>
-						</div>
-					)}
-				</CardContent>
-			</Card>
-
-			{/* TTN Configuration */}
-			<Card className="mt-6 w-full">
-				<CardHeader>
-					<CardTitle>TTN Configuration</CardTitle>
-					<CardDescription>
-						Configure your TTN (The Things Network) settings
-					</CardDescription>
-				</CardHeader>
-				<CardContent>
-					<div className="flex items-center justify-between space-x-2">
-						<Label htmlFor="ttnEnabled" className="text-base font-semibold">
-							Enable TTN
-						</Label>
-						<Switch
-							disabled
-							id="ttnEnabled"
-							checked={isTtnEnabled}
-							onCheckedChange={handleTtnToggle}
-						/>
-					</div>
-
-					{isTtnEnabled && (
-						<div className="space-y-4">
-							<div className="space-y-2">
-								<Label htmlFor="ttn-dev-id">Device ID</Label>
-								<Input
-									id="ttn-dev-id"
-									placeholder="Enter TTN Device ID"
-									{...register('dev_id')}
-									onChange={handleInputChange}
-								/>
-							</div>
-
-							<div className="space-y-2">
-								<Label htmlFor="ttn-app-id">Application ID</Label>
-								<Input
-									id="ttn-app-id"
-									placeholder="Enter TTN Application ID"
-									{...register('app_id')}
-									onChange={handleInputChange}
-								/>
-							</div>
-
-							<div className="space-y-2">
-								<Label htmlFor="ttn-profile">Profile</Label>
-								<Select
-									onValueChange={(value) =>
-										handleSelectChange('profile', value)
-									}
-									defaultValue={watch('profile')}
-								>
-									<SelectTrigger id="ttn-profile">
-										<SelectValue placeholder="Select a profile" />
-									</SelectTrigger>
-									<SelectContent>
-										<SelectItem value="lora-serialization">
-											Lora Serialization
-										</SelectItem>
-										<SelectItem value="sensebox/home">Sensebox/Home</SelectItem>
-										<SelectItem value="json">JSON</SelectItem>
-										<SelectItem value="debug">Debug</SelectItem>
-										<SelectItem value="cayenne-lpp">Cayenne LPP</SelectItem>
-									</SelectContent>
-								</Select>
-							</div>
-
-							<div className="space-y-2">
-								<Label htmlFor="ttn-decode-options">Decode Options</Label>
-								<Textarea
-									id="ttn-decode-options"
-									placeholder="Enter decode options as JSON"
-									className="resize-none"
-									{...register('decodeOptions')}
-									onChange={handleInputChange}
-								/>
-							</div>
-
-							<div className="space-y-2">
-								<Label htmlFor="ttn-port">Port</Label>
-								<Input
-									id="ttn-port"
-									placeholder="Enter TTN Port"
-									type="number"
-									{...register('port', { valueAsNumber: true })}
-									onChange={handleInputChange}
-								/>
-							</div>
-						</div>
-					)}
-				</CardContent>
-			</Card>
-		</>
-	)
-}
+  const { watch, setValue, resetField } = useFormContext();
+  const [integrations, setIntegrations] = useState<IntegrationMetadata[]>([]);
+  const [schemas, setSchemas] = useState<Record<string, { schema: any; uiSchema: any }>>({});
+  const [loading, setLoading] = useState<Record<string, boolean>>({});
+
+  // Load available integrations on mount
+  useEffect(() => {
+    const loadIntegrations = async () => {
+      try {
+        const res = await fetch("/api/integrations");
+        if (!res.ok) throw new Error("Failed to fetch integrations");
+        const data = await res.json();
+        setIntegrations(data);
+      } catch (err) {
+        console.error("Failed to load integrations", err);
+      }
+    };
+
+    void loadIntegrations();
+  }, []);
+
+  // Load schema when integration is enabled
+  const loadSchema = async (slug: string, schemaUrl: string) => {
+    if (schemas[slug]) return; // Already loaded
+
+    setLoading((prev) => ({ ...prev, [slug]: true }));
+
+    try {
+      console.log("schema url", schemaUrl)
+      const res = await fetch(schemaUrl);
+      if (!res.ok) throw new Error(`Failed to fetch ${slug} schema`);
+
+      const data = await res.json();
+      setSchemas((prev) => ({ ...prev, [slug]: data }));
+    } catch (err) {
+      console.error(`Failed to load ${slug} schema`, err);
+    } finally {
+      setLoading((prev) => ({ ...prev, [slug]: false }));
+    }
+  };
+
+  // Toggle handler
+  const handleToggle = (slug: string, checked: boolean, schemaUrl: string) => {
+    setValue(`${slug}Enabled`, checked);
+
+    if (checked) {
+      void loadSchema(slug, schemaUrl);
+    } else {
+      resetField(`${slug}Config`);
+    }
+  };
+
+  return (
+    <>
+      {integrations.map((intg) => {
+        const enabled = watch(`${intg.slug}Enabled`) ?? false;
+        const config = watch(`${intg.slug}Config`) ?? {};
+        const isLoading = loading[intg.slug] ?? false;
+        const schema = schemas[intg.slug];
+
+        return (
+          <Card key={intg.id} className="w-full mb-6">
+            <CardHeader>
+              <CardTitle>{intg.name} Configuration</CardTitle>
+              {intg.description && (
+                <CardDescription>{intg.description}</CardDescription>
+              )}
+            </CardHeader>
+
+            <CardContent className="space-y-4">
+              <div className="flex items-center justify-between">
+                <Label htmlFor={`${intg.slug}Enabled`} className="text-base font-semibold">
+                  Enable {intg.name}
+                </Label>
+                <Switch
+                  id={`${intg.slug}Enabled`}
+                  checked={enabled}
+                  onCheckedChange={(checked) => handleToggle(intg.slug, checked, intg.schemaUrl)}
+                />
+              </div>
+
+              {enabled && (
+                <>
+                  {isLoading && (
+                    <p className="text-sm text-muted-foreground">
+                      Loading {intg.name} configuration…
+                    </p>
+                  )}
+
+                  {schema && (
+                    <Form
+                      widgets={{ CheckboxWidget }}
+                      templates={{ FieldTemplate, BaseInputTemplate }}
+                      schema={schema.schema}
+                      uiSchema={schema.uiSchema}
+                      validator={validator}
+                      formData={config}
+                      onChange={(e) => {
+                        setValue(`${intg.slug}Config`, e.formData, {
+                          shouldDirty: true,
+                          shouldValidate: true,
+                        });
+                      }}
+                      onSubmit={() => {}}
+                    >
+                      <></>
+                    </Form>
+                  )}
+                </>
+              )}
+            </CardContent>
+          </Card>
+        );
+      })}
+    </>
+  );
+}
\ No newline at end of file
diff --git a/app/components/device/new/new-device-stepper.tsx b/app/components/device/new/new-device-stepper.tsx
index af5f2201..feda067a 100644
--- a/app/components/device/new/new-device-stepper.tsx
+++ b/app/components/device/new/new-device-stepper.tsx
@@ -87,40 +87,38 @@ const sensorsSchema = z.object({
 })
 
 const mqttSchema = z
-	.object({
-		mqttEnabled: z.boolean().default(false),
-		url: z.string().optional(),
-		topic: z.string().optional(),
-		messageFormat: z.enum(['json', 'csv']).optional(),
-		decodeOptions: z.string().optional(),
-		connectionOptions: z.string().optional(),
-	})
-	.superRefine((data, ctx) => {
-		if (data.mqttEnabled) {
-			// Check required fields when enabled is true
-			if (!data.url) {
-				ctx.addIssue({
-					path: ['url'],
-					message: 'URL is required when MQTT is enabled.',
-					code: 'custom',
-				})
-			}
-			if (!data.topic) {
-				ctx.addIssue({
-					path: ['topic'],
-					message: 'Topic is required when MQTT is enabled.',
-					code: 'custom',
-				})
-			}
-			if (!data.messageFormat) {
-				ctx.addIssue({
-					path: ['messageFormat'],
-					message: 'Message format is required when MQTT is enabled.',
-					code: 'custom',
-				})
-			}
-		}
-	})
+  .object({
+    mqttEnabled: z.boolean().default(false),
+    mqttConfig: z.record(z.any()).optional(),
+    ttnEnabled: z.boolean().default(false),
+    ttnConfig: z.record(z.any()).optional(),
+  })
+//   .superRefine((data, ctx) => {
+//     if (data.mqttEnabled) {
+//       // Check required fields when enabled is true
+//       if (!data.url) {
+//         ctx.addIssue({
+//           path: ["url"],
+//           message: "URL is required when MQTT is enabled.",
+//           code: "custom",
+//         });
+//       }
+//       if (!data.topic) {
+//         ctx.addIssue({
+//           path: ["topic"],
+//           message: "Topic is required when MQTT is enabled.",
+//           code: "custom",
+//         });
+//       }
+//       if (!data.messageFormat) {
+//         ctx.addIssue({
+//           path: ["messageFormat"],
+//           message: "Message format is required when MQTT is enabled.",
+//           code: "custom",
+//         });
+//       }
+//     }
+//   });
 
 const ttnSchema = z
 	.object({
@@ -167,52 +165,40 @@ const ttnSchema = z
 		}
 	})
 
-const advancedSchema = z.intersection(mqttSchema, ttnSchema)
+// const advancedSchema = z.intersection(mqttSchema, ttnSchema);
 
 export const Stepper = defineStepper(
-	{
-		id: 'general-info',
-		label: 'General Info',
-		info: 'Provide a unique name for your device, select its operating environment (outdoor, indoor, mobile, or unknown), and add relevant tags (optional).',
-		schema: generalInfoSchema,
-		index: 0,
-	},
-	{
-		id: 'location',
-		label: 'Location',
-		info: "Select the device's location by clicking on the map or entering latitude and longitude coordinates manually. Drag the marker on the map to adjust the location if needed.",
-		schema: locationSchema,
-		index: 1,
-	},
-	{
-		id: 'device-selection',
-		label: 'Device Selection',
-		info: 'Select a device model from the available options',
-		schema: deviceSchema,
-		index: 2,
-	},
-	{
-		id: 'sensor-selection',
-		label: 'Sensor Selection',
-		info: 'Select sensors for your device by choosing from predefined groups or individual sensors based on your device model. If using a custom device, configure sensors manually.',
-		schema: sensorsSchema,
-		index: 3,
-	},
-	{
-		id: 'advanced',
-		label: 'Advanced',
-		info: null,
-		schema: advancedSchema,
-		index: 4,
-	},
-	{
-		id: 'summary',
-		label: 'Summary',
-		info: null,
-		schema: z.object({}),
-		index: 5,
-	},
-)
+  {
+    id: "general-info",
+    label: "General Info",
+    info: "Provide a unique name for your device, select its operating environment (outdoor, indoor, mobile, or unknown), and add relevant tags (optional).",
+    schema: generalInfoSchema,
+    index: 0
+  },
+  {
+    id: "location",
+    label: "Location",
+    info: "Select the device's location by clicking on the map or entering latitude and longitude coordinates manually. Drag the marker on the map to adjust the location if needed.",
+    schema: locationSchema,
+    index: 1
+  },
+  {
+    id: "device-selection",
+    label: "Device Selection",
+    info: "Select a device model from the available options",
+    schema: deviceSchema,
+    index: 2
+  },
+  {
+    id: "sensor-selection",
+    label: "Sensor Selection",
+    info: "Select sensors for your device by choosing from predefined groups or individual sensors based on your device model. If using a custom device, configure sensors manually.",
+    schema: sensorsSchema,
+    index: 3
+  },
+  { id: "advanced", label: "Advanced", info: null,  schema: mqttSchema, index: 4 },
+  { id: "summary", label: "Summary", info: null, schema: z.object({}), index: 5 },
+);
 
 type GeneralInfoData = z.infer<typeof generalInfoSchema>
 type LocationData = z.infer<typeof locationSchema>
@@ -243,29 +229,27 @@ export default function NewDeviceStepper() {
 		setIsFirst(stepper.isFirst)
 	}, [stepper.isFirst])
 
-	const onSubmit = (data: FormData) => {
-		console.log('🚀 ~ onSubmit ~ data:', data)
-		const updatedData = {
-			...formData,
-			[stepper.current.id]: data,
-		}
+  const onSubmit = (data: FormData) => {
+    console.log("🚀 ~ onSubmit ~ data", data);    
+    const updatedData = {
+      ...formData,
+      [stepper.current.id]: data,
+    };
 
 		setFormData(updatedData)
 
-		if (stepper.isLast) {
-			console.log('Complete! Final Data:', updatedData)
-
-			// Submit form data as JSON
-			void submit(
-				{
-					formData: JSON.stringify(updatedData), // Serialize the data
-				},
-				{ method: 'post' },
-			)
-		} else {
-			stepper.next()
-		}
-	}
+    if (stepper.isLast) {
+      // Submit form data as JSON
+      void submit(
+        {
+          formData: JSON.stringify(updatedData),
+        },
+        { method: "post" },
+      );
+    } else {
+      stepper.next();
+    }
+  };
 
 	const onError = (errors: FieldErrors<FormData>) => {
 		const firstErrorMessage = Object.values(errors)?.[0]?.message
diff --git a/app/components/rjsf/checkboxWidget.tsx b/app/components/rjsf/checkboxWidget.tsx
new file mode 100644
index 00000000..e8a56504
--- /dev/null
+++ b/app/components/rjsf/checkboxWidget.tsx
@@ -0,0 +1,14 @@
+import  { type WidgetProps } from "@rjsf/utils";
+import { Checkbox } from "@/components/ui/checkbox";
+
+export function CheckboxWidget({ value, onChange, label }: WidgetProps) {
+  return (
+    <div className="flex items-center gap-2">
+      <Checkbox
+        checked={Boolean(value)}
+        onCheckedChange={onChange}
+      />
+      <span className="text-sm">{label}</span>
+    </div>
+  );
+}
diff --git a/app/components/rjsf/fieldTemplate.tsx b/app/components/rjsf/fieldTemplate.tsx
new file mode 100644
index 00000000..dcb3061f
--- /dev/null
+++ b/app/components/rjsf/fieldTemplate.tsx
@@ -0,0 +1,39 @@
+import { type FieldTemplateProps } from "@rjsf/utils";
+
+export function FieldTemplate(props: FieldTemplateProps) {
+  const {
+    id,
+    classNames,
+    style,
+    label,
+    help,
+    required,
+    errors,
+    children,
+  } = props;
+
+  return (
+    <div className={classNames} style={style}>
+      {label && (
+        <label htmlFor={id} className="block text-sm font-medium text-gray-700 mb-1">
+          {label}
+          {required && <span className="text-red-500">*</span>}
+        </label>
+      )}
+      
+      {children}
+      
+      {/* {help && (
+        <div className="mt-1 text-sm text-gray-500">
+          {help}
+        </div>
+      )} */}
+      
+      {errors && (
+        <div className="mt-1 text-sm text-red-600">
+          {errors}
+        </div>
+      )}
+    </div>
+  );
+}
\ No newline at end of file
diff --git a/app/components/rjsf/inputTemplate.tsx b/app/components/rjsf/inputTemplate.tsx
new file mode 100644
index 00000000..31163494
--- /dev/null
+++ b/app/components/rjsf/inputTemplate.tsx
@@ -0,0 +1,39 @@
+import  { type BaseInputTemplateProps } from "@rjsf/utils";
+
+export function BaseInputTemplate(props: BaseInputTemplateProps) {
+  const {
+    id,
+    value,
+    required,
+    disabled,
+    readonly,
+    autofocus,
+    onChange,
+    onBlur,
+    onFocus,
+    options,
+    placeholder,
+    type,
+  } = props;
+
+  return (
+    <input
+      id={id}
+      type={type ?? "text"}
+      value={value ?? ""}
+      required={required}
+      disabled={disabled || readonly}
+      autoFocus={autofocus}
+      placeholder={placeholder}
+      onChange={(e) => onChange(e.target.value)}
+      onBlur={() => onBlur(id, value)}
+      onFocus={() => onFocus(id, value)}
+      className="
+        w-full rounded-md border border-gray-300
+        px-3 py-2 text-sm
+        focus:outline-none focus:ring-2 focus:ring-green-500
+        disabled:bg-gray-100 disabled:cursor-not-allowed
+      "
+    />
+  );
+}
diff --git a/app/components/rjsf/numberWidget.tsx b/app/components/rjsf/numberWidget.tsx
new file mode 100644
index 00000000..3dd407e8
--- /dev/null
+++ b/app/components/rjsf/numberWidget.tsx
@@ -0,0 +1,16 @@
+import { type WidgetProps } from "@rjsf/utils";
+
+export function NumberWidget(props: WidgetProps) {
+  return (
+    <input
+      id={props.id}
+      type="number"
+      value={props.value ?? ""}
+      onChange={(e) => props.onChange(e.target.valueAsNumber || undefined)}
+      disabled={props.disabled || props.readonly}
+      min={props.schema.minimum}
+      max={props.schema.maximum}
+      className="w-full rounded-md border border-gray-300 px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-green-500"
+    />
+  );
+}
\ No newline at end of file
diff --git a/app/components/rjsf/selectWidget.tsx b/app/components/rjsf/selectWidget.tsx
new file mode 100644
index 00000000..edc6d45f
--- /dev/null
+++ b/app/components/rjsf/selectWidget.tsx
@@ -0,0 +1,32 @@
+import { type WidgetProps } from "@rjsf/utils";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "~/components/ui/select";
+
+export function SelectWidget(props: WidgetProps) {
+  const { id, value, required, disabled, readonly, onChange, options, placeholder } = props;
+
+  return (
+    <Select
+      value={value || ""}
+      onValueChange={onChange}
+      disabled={disabled || readonly}
+      required={required}
+    >
+      <SelectTrigger id={id}>
+        <SelectValue placeholder={placeholder || "Select an option"} />
+      </SelectTrigger>
+      <SelectContent>
+        {options.enumOptions?.map((option) => (
+          <SelectItem key={option.value} value={String(option.value)}>
+            {option.label}
+          </SelectItem>
+        ))}
+      </SelectContent>
+    </Select>
+  );
+}
\ No newline at end of file
diff --git a/app/components/rjsf/textareaWidget.tsx b/app/components/rjsf/textareaWidget.tsx
new file mode 100644
index 00000000..a351d936
--- /dev/null
+++ b/app/components/rjsf/textareaWidget.tsx
@@ -0,0 +1,13 @@
+import { type WidgetProps } from "@rjsf/utils";
+
+export function TextareaWidget(props: WidgetProps) {
+  return (
+    <textarea
+      id={props.id}
+      value={props.value ?? ""}
+      onChange={(e) => props.onChange(e.target.value)}
+      rows={4}
+      className="w-full rounded-md border border-gray-300 px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-green-500"
+    />
+  );
+}
\ No newline at end of file
diff --git a/app/lib/decoding-service.server.ts b/app/lib/decoding-service.server.ts
index 620d2f0f..040615d2 100644
--- a/app/lib/decoding-service.server.ts
+++ b/app/lib/decoding-service.server.ts
@@ -67,7 +67,7 @@ const decodeHandlers: {
 		decodeMessage: (body: any, { sensors }: { sensors: any[] }) => {
 			if (Array.isArray(body)) {
 				return body.map((measurement) => ({
-					sensor_id: measurement.sensor,
+					sensor_id: measurement.sensor_id ?? measurement.sensor,
 					value: parseFloat(measurement.value),
 					createdAt: measurement.createdAt
 						? new Date(measurement.createdAt)
diff --git a/app/lib/env.ts b/app/lib/env.ts
new file mode 100644
index 00000000..45f0646c
--- /dev/null
+++ b/app/lib/env.ts
@@ -0,0 +1,6 @@
+import "dotenv/config"
+
+export const env = {
+  MQTT_SERVICE_URL: process.env.MQTT_SERVICE_URL!,
+  MQTT_SERVICE_KEY: process.env.MQTT_SERVICE_KEY!,
+}
\ No newline at end of file
diff --git a/app/lib/integration.openapi.ts b/app/lib/integration.openapi.ts
new file mode 100644
index 00000000..89e3ec67
--- /dev/null
+++ b/app/lib/integration.openapi.ts
@@ -0,0 +1,458 @@
+import swaggerJsdoc from "swagger-jsdoc";
+
+const options: swaggerJsdoc.Options = {
+  definition: {
+    openapi: "3.0.0",
+    info: {
+      title: "OpenSenseMap Integration API",
+      version: "1.0.0",
+      description: `
+# Building OpenSenseMap Integrations
+
+OpenSenseMap uses a plugin architecture for integrations. Any service implementing this specification can connect devices from any platform or protocol to OpenSenseMap.
+
+## Architecture
+
+\`\`\`
+OpenSenseMap (Main App)
+    ↓ Registers & calls via HTTP
+Your Integration Service
+    ↓ Receives data from
+Your Protocol (MQTT/LoRa/etc.)
+\`\`\`
+
+## Required Endpoints
+
+Your integration service MUST implement these endpoints:
+
+1. **GET /integrations/:deviceId** - Get integration config
+2. **PUT /integrations/:deviceId** - Create/update integration config
+3. **DELETE /integrations/:deviceId** - Delete integration config
+4. **GET /integrations/schema/{name}** - Return JSON Schema for config form
+5. **GET /health** - Health check
+
+## Authentication
+
+All endpoints (except /health) require \`x-service-key\` header.
+
+## Forwarding Measurements
+
+After processing data, POST measurements to OpenSenseMap:
+
+**Endpoint:** \`POST /api/boxes/:deviceId/:sensorId\`
+
+**Headers:**
+- \`Content-Type: application/json\`
+- \`x-service-key\`: Your service key (provided by OpenSenseMap)
+
+**Body:**
+\`\`\`json
+{
+  "value": 23.5,
+  "createdAt": "2026-02-06T10:00:00Z",
+  "location": {
+    "lng": 7.628,
+    "lat": 51.963,
+    "height": 100
+  }
+}
+\`\`\`
+
+## Reference Implementations
+
+- [MQTT Integration](https://github.com/opensensemap/mqtt-integration)
+- [TTN Integration](https://github.com/opensensemap/ttn-integration)
+
+## Registration
+
+To register your integration, contact OpenSenseMap admins with:
+- Service name and description
+- Service URL and authentication key
+- Icon (Lucide icon name)
+- JSON Schema endpoint path
+      `,
+    },
+    servers: [
+      {
+        url: "https://your-integration-service.com",
+        description: "Your integration microservice",
+      },
+    ],
+    components: {
+      securitySchemes: {
+        ServiceKey: {
+          type: "apiKey",
+          in: "header",
+          name: "x-service-key",
+          description: "Service authentication key configured in OpenSenseMap",
+        },
+      },
+      parameters: {
+        DeviceId: {
+          name: "deviceId",
+          in: "path",
+          required: true,
+          schema: {
+            type: "string",
+          },
+          description: "OpenSenseMap device ID",
+          example: "cm65qexample123",
+        },
+      },
+      schemas: {
+        IntegrationConfig: {
+          type: "object",
+          description: "Integration configuration (schema varies by integration type)",
+          additionalProperties: true,
+          example: {
+            id: "intg_123",
+            deviceId: "cm65qexample123",
+            enabled: true,
+            url: "mqtt://broker.example.com",
+            topic: "sensors/data",
+            messageFormat: "json",
+          },
+        },
+        JsonSchema: {
+          type: "object",
+          description: "JSON Schema (draft-07) for dynamic form generation",
+          properties: {
+            schema: {
+              type: "object",
+              description: "JSON Schema definition",
+            },
+            uiSchema: {
+              type: "object",
+              description: "React JSON Schema Form UI Schema",
+            },
+          },
+          required: ["schema"],
+        },
+        Error: {
+          type: "object",
+          properties: {
+            error: {
+              type: "string",
+            },
+            details: {
+              type: "array",
+              items: {
+                type: "string",
+              },
+            },
+          },
+        },
+      },
+      responses: {
+        NotFound: {
+          description: "Resource not found",
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/Error",
+              },
+              example: {
+                error: "Integration not found",
+              },
+            },
+          },
+        },
+        ValidationError: {
+          description: "Validation failed",
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/Error",
+              },
+              example: {
+                error: "Validation failed",
+                details: [
+                  "url is required and must be a string",
+                  "topic is required and must be a string",
+                ],
+              },
+            },
+          },
+        },
+        Unauthorized: {
+          description: "Unauthorized - invalid or missing service key",
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/Error",
+              },
+              example: {
+                error: "Unauthorized",
+              },
+            },
+          },
+        },
+        InternalError: {
+          description: "Internal server error",
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/Error",
+              },
+              example: {
+                error: "Internal server error",
+              },
+            },
+          },
+        },
+      },
+    },
+    security: [
+      {
+        ServiceKey: [],
+      },
+    ],
+    tags: [
+      {
+        name: "Integration Management",
+        description: "CRUD operations for integration configurations",
+      },
+      {
+        name: "Schema",
+        description: "JSON Schema for dynamic form generation",
+      },
+      {
+        name: "Health",
+        description: "Service health check",
+      },
+    ],
+    paths: {
+      "/integrations/{deviceId}": {
+        get: {
+          summary: "Get integration configuration for a device",
+          operationId: "getIntegration",
+          tags: ["Integration Management"],
+          parameters: [
+            {
+              $ref: "#/components/parameters/DeviceId",
+            },
+          ],
+          responses: {
+            "200": {
+              description: "Integration configuration",
+              content: {
+                "application/json": {
+                  schema: {
+                    $ref: "#/components/schemas/IntegrationConfig",
+                  },
+                },
+              },
+            },
+            "404": {
+              $ref: "#/components/responses/NotFound",
+            },
+            "401": {
+              $ref: "#/components/responses/Unauthorized",
+            },
+            "500": {
+              $ref: "#/components/responses/InternalError",
+            },
+          },
+        },
+        put: {
+          summary: "Create or update integration configuration",
+          operationId: "createOrUpdateIntegration",
+          tags: ["Integration Management"],
+          parameters: [
+            {
+              $ref: "#/components/parameters/DeviceId",
+            },
+          ],
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  description: "Configuration specific to your integration type",
+                  additionalProperties: true,
+                },
+                examples: {
+                  mqtt: {
+                    summary: "MQTT Integration",
+                    value: {
+                      url: "mqtt://broker.example.com:1883",
+                      topic: "sensors/temperature",
+                      messageFormat: "json",
+                      connectionOptions: {
+                        username: "user",
+                        password: "pass",
+                      },
+                    },
+                  },
+                  ttn: {
+                    summary: "TTN Integration",
+                    value: {
+                      devId: "my-device",
+                      appId: "my-app",
+                      profile: "cayenne-lpp",
+                    },
+                  },
+                },
+              },
+            },
+          },
+          responses: {
+            "200": {
+              description: "Integration updated",
+              content: {
+                "application/json": {
+                  schema: {
+                    $ref: "#/components/schemas/IntegrationConfig",
+                  },
+                },
+              },
+            },
+            "201": {
+              description: "Integration created",
+              content: {
+                "application/json": {
+                  schema: {
+                    $ref: "#/components/schemas/IntegrationConfig",
+                  },
+                },
+              },
+            },
+            "400": {
+              $ref: "#/components/responses/ValidationError",
+            },
+            "401": {
+              $ref: "#/components/responses/Unauthorized",
+            },
+            "500": {
+              $ref: "#/components/responses/InternalError",
+            },
+          },
+        },
+        delete: {
+          summary: "Delete integration configuration",
+          operationId: "deleteIntegration",
+          tags: ["Integration Management"],
+          parameters: [
+            {
+              $ref: "#/components/parameters/DeviceId",
+            },
+          ],
+          responses: {
+            "204": {
+              description: "Integration deleted successfully",
+            },
+            "404": {
+              $ref: "#/components/responses/NotFound",
+            },
+            "401": {
+              $ref: "#/components/responses/Unauthorized",
+            },
+            "500": {
+              $ref: "#/components/responses/InternalError",
+            },
+          },
+        },
+      },
+      "/integrations/schema/{integrationName}": {
+        get: {
+          summary: "Get JSON Schema for integration configuration form",
+          operationId: "getIntegrationSchema",
+          tags: ["Schema"],
+          parameters: [
+            {
+              name: "integrationName",
+              in: "path",
+              required: true,
+              schema: {
+                type: "string",
+              },
+              example: "mqtt",
+            },
+          ],
+          responses: {
+            "200": {
+              description: "JSON Schema for dynamic form generation",
+              content: {
+                "application/json": {
+                  schema: {
+                    $ref: "#/components/schemas/JsonSchema",
+                  },
+                  examples: {
+                    mqtt: {
+                      summary: "MQTT Schema Example",
+                      value: {
+                        schema: {
+                          type: "object",
+                          required: ["url", "topic", "messageFormat"],
+                          properties: {
+                            url: {
+                              type: "string",
+                              title: "Broker URL",
+                              pattern: "^(mqtt|mqtts|ws|wss)://.+",
+                            },
+                            topic: {
+                              type: "string",
+                              title: "Topic",
+                            },
+                            messageFormat: {
+                              type: "string",
+                              title: "Message Format",
+                              enum: ["json", "csv"],
+                            },
+                          },
+                        },
+                        uiSchema: {
+                          "ui:order": ["url", "topic", "messageFormat"],
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+            "401": {
+              $ref: "#/components/responses/Unauthorized",
+            },
+            "500": {
+              $ref: "#/components/responses/InternalError",
+            },
+          },
+        },
+      },
+      "/health": {
+        get: {
+          summary: "Health check endpoint",
+          operationId: "healthCheck",
+          tags: ["Health"],
+          security: [],
+          responses: {
+            "200": {
+              description: "Service is healthy",
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    properties: {
+                      status: {
+                        type: "string",
+                        example: "healthy",
+                      },
+                      timestamp: {
+                        type: "string",
+                        format: "date-time",
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  apis: [],
+};
+
+export const integrationOpenapiSpecification = () => swaggerJsdoc(options);
\ No newline at end of file
diff --git a/app/lib/lucide-icon-map.ts b/app/lib/lucide-icon-map.ts
new file mode 100644
index 00000000..fdeb55d3
--- /dev/null
+++ b/app/lib/lucide-icon-map.ts
@@ -0,0 +1,12 @@
+import * as LucideIcons from "lucide-react";
+import  { type LucideIcon } from "lucide-react";
+
+const iconMap = LucideIcons as unknown as Record<string, LucideIcon>;
+
+export function getLucideIcon(name?: string | null): LucideIcon {
+  if (!name) {
+    return LucideIcons.Plug;
+  }
+
+  return iconMap[name] ?? LucideIcons.Plug;
+}
diff --git a/app/lib/mqttClient.ts b/app/lib/mqttClient.ts
new file mode 100644
index 00000000..3e83016f
--- /dev/null
+++ b/app/lib/mqttClient.ts
@@ -0,0 +1,104 @@
+import { env } from "./env"
+import { setMqttIntegrationEnabled } from "~/models/integration.server"
+
+interface MqttClientResponse {
+  success: boolean
+  deviceId: string
+}
+
+interface MqttStatusResponse {
+  deviceId: string
+  connected: boolean
+}
+
+interface MqttHealthResponse {
+  status: string
+  connections: number
+  timestamp: string
+}
+
+class MqttClient {
+    private baseUrl = env.MQTT_SERVICE_URL
+    private serviceKey = env.MQTT_SERVICE_KEY
+
+  private async request<T>(
+    endpoint: string,
+    options: RequestInit = {}
+  ): Promise<T> {
+    const url = `${this.baseUrl}${endpoint}`
+    
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        'Content-Type': 'application/json',
+        'x-service-key': this.serviceKey,
+        ...options.headers,
+      },
+    })
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ 
+        error: 'Unknown error' 
+      }))
+      throw new Error(
+        `MQTT Service error: ${response.status} - ${error.error || error.message || 'Unknown error'}`
+      )
+    }
+
+    return response.json()
+  }
+
+  /**
+   * Connect a device to its MQTT broker
+   */
+  async connectBox(params: { box_id: string }): Promise<MqttClientResponse> {
+    await setMqttIntegrationEnabled(params.box_id, true)
+    return this.request<MqttClientResponse>(
+      `/devices/${params.box_id}/connect`,
+      { method: 'POST' }
+    )
+  }
+
+  /**
+   * Disconnect a device from its MQTT broker
+   */
+  async disconnectBox(params: { box_id: string }): Promise<MqttClientResponse> {
+    await setMqttIntegrationEnabled(params.box_id, false)
+    return this.request<MqttClientResponse>(
+      `/devices/${params.box_id}/disconnect`,
+      { method: 'POST' }
+    )
+  }
+
+  /**
+   * Reconnect a device (disconnect then connect with fresh config)
+   */
+  async reconnectBox(params: { box_id: string }): Promise<MqttClientResponse> {
+    return this.request<MqttClientResponse>(
+      `/devices/${params.box_id}/reconnect`,
+      { method: 'POST' }
+    )
+  }
+
+  /**
+   * Get connection status for a device
+   */
+  async getStatus(deviceId: string): Promise<MqttStatusResponse> {
+    return this.request<MqttStatusResponse>(
+      `/devices/${deviceId}/status`,
+      { method: 'GET' }
+    )
+  }
+
+  /**
+   * Get health status of the MQTT service
+   */
+  async getHealth(): Promise<MqttHealthResponse> {
+    return this.request<MqttHealthResponse>(
+      '/health',
+      { method: 'GET' }
+    )
+  }
+}
+
+export const mqttClient = new MqttClient()
\ No newline at end of file
diff --git a/app/lib/openapi.combined.ts b/app/lib/openapi.combined.ts
new file mode 100644
index 00000000..497942fa
--- /dev/null
+++ b/app/lib/openapi.combined.ts
@@ -0,0 +1,111 @@
+import { type OpenAPIV3 } from "openapi-types";
+import { integrationOpenapiSpecification } from "./integration.openapi";
+import { openapiSpecification } from "./openapi";
+
+type OpenAPIDocumentWithTagGroups = OpenAPIV3.Document & {
+  "x-tagGroups"?: Array<{
+    name: string;
+    tags: string[];
+  }>;
+};
+
+function prefixOperationTags(
+  paths: OpenAPIV3.PathsObject,
+  prefix: string,
+): OpenAPIV3.PathsObject {
+  const result: OpenAPIV3.PathsObject = {};
+
+  for (const [path, methods] of Object.entries(paths)) {
+    result[path] = {};
+
+    for (const [method, operation] of Object.entries(methods ?? {})) {
+      if (!operation || typeof operation !== "object") continue;
+
+      const op = operation as OpenAPIV3.OperationObject;
+
+      result[path]![method as OpenAPIV3.HttpMethods] = {
+        ...op,
+        tags: op.tags?.map((t) => `${prefix} · ${t}`),
+      };
+    }
+  }
+
+  return result;
+}
+
+export const combinedOpenapiSpecification =
+  (): OpenAPIDocumentWithTagGroups => {
+    const main = openapiSpecification() as OpenAPIV3.Document;
+    const integration =
+      integrationOpenapiSpecification() as OpenAPIV3.Document;
+
+    return {
+      ...main,
+
+      info: {
+        ...main.info,
+        title: "OpenSenseMap API",
+        description: `
+# OpenSenseMap API Documentation
+
+Use the links below or the sidebar to navigate.
+
+- Public API
+- Integration API
+        `,
+      },
+
+      tags: [
+        ...(main.tags ?? []).map((t) => ({
+          ...t,
+          name: `Public · ${t.name}`,
+        })),
+        ...(integration.tags ?? []).map((t) => ({
+          ...t,
+          name: `Integration · ${t.name}`,
+        })),
+      ],
+
+      paths: {
+        ...prefixOperationTags(main.paths ?? {}, "Public"),
+        ...prefixOperationTags(integration.paths ?? {}, "Integration"),
+      },
+
+      components: {
+        schemas: {
+          ...main.components?.schemas,
+          ...integration.components?.schemas,
+        },
+        parameters: {
+          ...main.components?.parameters,
+          ...integration.components?.parameters,
+        },
+        responses: {
+          ...main.components?.responses,
+          ...integration.components?.responses,
+        },
+        securitySchemes: {
+          ...main.components?.securitySchemes,
+          ...integration.components?.securitySchemes,
+        },
+      },
+
+      security: [
+        ...(main.security ?? []),
+        ...(integration.security ?? []),
+      ],
+
+      "x-tagGroups": [
+        {
+          name: "Public API",
+          tags: (main.tags ?? []).map((t) => `Public · ${t.name}`),
+        },
+        {
+          name: "Integration API",
+          tags: (integration.tags ?? []).map(
+            (t) => `Integration · ${t.name}`,
+          ),
+        },
+      ],
+    };
+  };
diff --git a/app/models/integration.server.ts b/app/models/integration.server.ts
new file mode 100644
index 00000000..68b19f2f
--- /dev/null
+++ b/app/models/integration.server.ts
@@ -0,0 +1,13 @@
+import { asc, eq } from "drizzle-orm";
+import { drizzleClient } from "~/db.server";
+import { type Integration, integration } from "~/schema/integration";
+
+export async function getIntegrations() {
+  return drizzleClient.query.integration.findMany({
+      orderBy: [asc(integration.order)],
+  })
+}
+
+export async function getIntegrationById({ id }: Pick<Integration, "id">){
+  return drizzleClient.query.integration.findFirst({where: eq(integration.id, id)})
+}
diff --git a/app/routes/api.boxes.$deviceId.data.ts b/app/routes/api.boxes.$deviceId.data.ts
index 00a92d3f..ac40c6d7 100644
--- a/app/routes/api.boxes.$deviceId.data.ts
+++ b/app/routes/api.boxes.$deviceId.data.ts
@@ -16,8 +16,11 @@ export const action: ActionFunction = async ({
 		const hackair = searchParams.get('hackair') !== null
 
 		const contentType = request.headers.get('content-type') || ''
+		const mqttServiceKey = request.headers.get('x-service-key')
 		const authorization = request.headers.get('authorization')
 
+		const isMqttRequest = mqttServiceKey === process.env.MQTT_SERVICE_KEY
+
 		let body: any
 		if (contentType.includes('application/json')) {
 			body = await request.json()
@@ -33,7 +36,7 @@ export const action: ActionFunction = async ({
 			contentType,
 			luftdaten,
 			hackair,
-			authorization,
+			authorization: isMqttRequest ? undefined : authorization,
 		})
 
 		return new Response('Measurements saved in box', {
diff --git a/app/routes/api.integrations.schema.$slug.ts b/app/routes/api.integrations.schema.$slug.ts
new file mode 100644
index 00000000..43c8baaf
--- /dev/null
+++ b/app/routes/api.integrations.schema.$slug.ts
@@ -0,0 +1,49 @@
+import { eq } from "drizzle-orm";
+import { type LoaderFunctionArgs } from "react-router";
+import { drizzleClient } from "~/db.server";
+import { integration } from "~/schema/integration";
+
+export async function loader({ params }: LoaderFunctionArgs) {
+  const { slug } = params;
+
+  if (!slug) {
+    return new Response("Integration slug required", { status: 400 });
+  }
+
+  try {
+    const intg = await drizzleClient.query.integration.findFirst({
+      where: eq(integration.slug, slug),
+    });
+
+    if (!intg) {
+      return new Response(`Integration '${slug}' not found`, { status: 404 });
+    }
+
+    const serviceKey = process.env[intg.serviceKeyEnvVar];
+    if (!serviceKey) {
+      return new Response(
+        `Service key env var '${intg.serviceKeyEnvVar}' not configured`,
+        { status: 500 }
+      );
+    }
+
+    const res = await fetch(`${intg.serviceUrl}${intg.schemaPath}`, {
+      headers: {
+        "x-service-key": serviceKey,
+      },
+    });
+
+    if (!res.ok) {
+      return new Response(`Failed to fetch schema from ${intg.name} service`, {
+        status: res.status,
+      });
+    }
+
+    const schema = await res.json();
+
+    return Response.json(schema);
+  } catch (error) {
+    console.error("Error fetching integration schema:", error);
+    return new Response("Internal server error", { status: 500 });
+  }
+}
\ No newline at end of file
diff --git a/app/routes/api.integrations.ts b/app/routes/api.integrations.ts
new file mode 100644
index 00000000..d1d2cc3e
--- /dev/null
+++ b/app/routes/api.integrations.ts
@@ -0,0 +1,31 @@
+import { type LoaderFunctionArgs } from "react-router";
+import { getIntegrations } from "~/models/integration.server";
+
+export interface IntegrationMetadata {
+  id: string;
+  name: string;
+  slug: string;
+  icon?: string;
+  description?: string;
+  schemaUrl: string;
+}
+
+export async function loader({}: LoaderFunctionArgs) {
+  try {
+    const integrations = await getIntegrations()
+
+    return Response.json(
+      integrations.map((intg) => ({
+        id: intg.id,
+        name: intg.name,
+        slug: intg.slug,
+        icon: intg.icon,
+        description: intg.description,
+        schemaUrl: `/api/integrations/schema/${intg.slug}`,
+      }))
+    );
+  } catch (error) {
+    console.error("Error fetching integrations:", error);
+    return new Response("Internal server error", { status: 500 });
+  }
+}
\ No newline at end of file
diff --git a/app/routes/api.measurements.ingest.ts b/app/routes/api.measurements.ingest.ts
new file mode 100644
index 00000000..06c9746f
--- /dev/null
+++ b/app/routes/api.measurements.ingest.ts
@@ -0,0 +1,70 @@
+import { type ActionFunctionArgs } from 'react-router'
+import { z } from 'zod'
+import { getDevice } from '~/models/device.server'
+import { saveMeasurements } from '~/models/measurement.server'
+import { StandardResponse } from '~/utils/response-utils'
+
+const MeasurementSchema = z.object({
+	sensor_id: z.string(),
+	value: z.number(),
+	createdAt: z.string().datetime(),
+	location: z
+		.object({
+			lat: z.number(),
+			lng: z.number(),
+			altitude: z.number().optional(),
+		})
+		.optional(),
+})
+
+const BatchMeasurementSchema = z.object({
+	deviceId: z.string(),
+	measurements: z.array(MeasurementSchema),
+})
+
+export async function action({ request }: ActionFunctionArgs) {
+	try {
+		let body
+		try {
+			body = await request.json()
+		} catch (err) {
+			return StandardResponse.badRequest('Invalid JSON in request body')
+		}
+
+		const validationResult = BatchMeasurementSchema.safeParse(body)
+		if (!validationResult.success) {
+			return StandardResponse.badRequest(
+				validationResult.error.errors[0].message,
+			)
+		}
+
+		const { deviceId, measurements: rawMeasurements } = validationResult.data
+
+		const device = await getDevice({ id: deviceId })
+		if (!device) {
+			return StandardResponse.notFound('Device not found')
+		}
+
+		if (!device.sensors || device.sensors.length === 0) {
+			return StandardResponse.badRequest('Device has no sensors configured')
+		}
+
+		const measurements = rawMeasurements.map((m) => ({
+			sensor_id: m.sensor_id,
+			value: m.value,
+			createdAt: m.createdAt ? new Date(m.createdAt) : undefined,
+			location: m.location,
+		}))
+
+		try {
+			await saveMeasurements(device, measurements)
+		} catch (saveErr) {
+			// Still return 202
+		}
+
+		return new Response(null, { status: 202 })
+	} catch (err) {
+		if (err instanceof Response) throw err
+		return StandardResponse.internalServerError()
+	}
+}
diff --git a/app/routes/device.$deviceId.edit.mqtt.tsx b/app/routes/device.$deviceId.edit.mqtt.tsx
index 59b9aa9c..9978ad57 100644
--- a/app/routes/device.$deviceId.edit.mqtt.tsx
+++ b/app/routes/device.$deviceId.edit.mqtt.tsx
@@ -1,310 +1,174 @@
-import { Save } from 'lucide-react'
-import React, { useState } from 'react'
-import {
-	data,
-	redirect,
-	Form,
-	useActionData,
-	type ActionFunctionArgs,
-	type LoaderFunctionArgs,
-} from 'react-router'
-import { Checkbox } from '@/components/ui/checkbox'
-import { Label } from '@/components/ui/label'
-import { RadioGroup, RadioGroupItem } from '@/components/ui/radio-group'
-import ErrorMessage from '~/components/error-message'
-import { toast } from '~/components/ui/use-toast'
-import { checkMqttValidaty } from '~/models/mqtt.server'
-import { getUserId } from '~/utils/session.server'
+import Form from "@rjsf/core";
+import validator from "@rjsf/validator-ajv8";
+import { Save } from "lucide-react";
+import React, { useState } from "react";
+import { data, redirect , useFetcher, useLoaderData, type ActionFunctionArgs, type LoaderFunctionArgs  } from "react-router";
+import ErrorMessage from "~/components/error-message";
+import { CheckboxWidget } from "~/components/rjsf/checkboxWidget";
+import { FieldTemplate } from "~/components/rjsf/fieldTemplate";
+import { BaseInputTemplate } from "~/components/rjsf/inputTemplate";
+import { toast } from "~/components/ui/use-toast";
+import { getUserId } from "~/utils/session.server";
 
 //*****************************************************
-export async function loader({ request }: LoaderFunctionArgs) {
-	//* if user is not logged in, redirect to home
-	const userId = await getUserId(request)
-	if (!userId) return redirect('/')
-
-	return ''
+export async function loader({ request, params }: LoaderFunctionArgs) {
+  const userId = await getUserId(request);
+  if (!userId) return redirect("/");
+  const { deviceId } = params;
+
+  try {
+    const headers = {
+    "x-service-key": process.env.MQTT_SERVICE_KEY!,
+  };
+    
+     const [schemaRes, integrationRes] = await Promise.all([
+    fetch(`${process.env.MQTT_SERVICE_URL}/integrations/schema/mqtt`, { headers }),
+    fetch(`${process.env.MQTT_SERVICE_URL}/integrations/${deviceId}`, { headers }),
+  ]);
+
+  if (!schemaRes.ok) {
+    throw new Response("Failed to load MQTT schema", { status: 500 });
+  }
+
+  const schemaData = await schemaRes.json();
+
+  let integration = null;
+  if (integrationRes.ok) {
+    integration = await integrationRes.json();
+  }
+
+  const data = {
+    schema: schemaData.schema,
+    uiSchema: schemaData.uiSchema,
+    integration,
+  };
+
+  return data;
+}
+  catch{
+    console.log("err")
+  }
 }
 
-//*****************************************************
-export async function action({ request }: ActionFunctionArgs) {
-	const formData = await request.formData()
-	const { enableMQTTcb, mqttURL, mqttTopic } = Object.fromEntries(formData)
-
-	//* ToDo: if mqtt checkbox is not enabled, reset mqtt to default
-	if (!enableMQTTcb) {
-		return data({
-			errors: {
-				mqttURL: null,
-				mqttTopic: null,
-			},
-			reset: true,
-			isMqttValid: null,
-			status: 200,
-		})
-	}
-
-	const errors = {
-		mqttURL: mqttURL ? null : 'Invalid URL (please use ws or wss URL)',
-		mqttTopic: mqttTopic ? null : 'Invalid mqtt topic',
-	}
-	const hasErrors = Object.values(errors).some((errorMessage) => errorMessage)
-
-	if (hasErrors) {
-		return data({
-			errors: errors,
-			reset: false,
-			isMqttValid: null,
-			status: 400,
-		})
-	}
-
-	//* check mqtt connection validity
-	const isMqttValid = await checkMqttValidaty(mqttURL.toString())
-
-	return data({
-		errors: errors,
-		reset: false,
-		isMqttValid: isMqttValid,
-		status: 200,
-	})
+export async function action({ request, params }: ActionFunctionArgs) {
+  const { deviceId } = params;
+  
+  const formData = await request.formData();
+  const mqttConfigStr = formData.get("mqttConfig");
+  
+  if (!mqttConfigStr) {
+    return data({ error: "No MQTT config provided" }, { status: 400 });
+  }
+
+  const mqttConfig = JSON.parse(mqttConfigStr.toString());
+  
+  const serviceUrl = process.env.MQTT_SERVICE_URL;
+  const serviceKey = process.env.MQTT_SERVICE_KEY;
+
+  if (!serviceUrl || !serviceKey) {
+    throw new Error("MQTT service env vars are not configured");
+  }
+
+  if (!mqttConfig.enabled) {
+    await fetch(`${serviceUrl}/integrations/${deviceId}`, {
+      method: 'DELETE',
+      headers: { 'x-service-key': serviceKey }
+    });
+    return data({ success: true });
+  }
+
+  // Create or update integration
+  const response = await fetch(`${serviceUrl}/integrations/${deviceId}`, {
+    method: 'PUT',
+    headers: { 
+      'Content-Type': 'application/json',
+      'x-service-key': serviceKey
+    },
+    body: JSON.stringify({
+      url: mqttConfig.url,
+      topic: mqttConfig.topic,
+      messageFormat: mqttConfig.messageFormat,
+      decodeOptions: mqttConfig.decodeOptions,
+      connectionOptions: mqttConfig.connectionOptions,
+    })
+  });
+
+  if (!response.ok) {
+    const error = await response.json();
+    return data({ 
+      error: error.error || error.details || 'Failed to save configuration' 
+    }, { status: response.status });
+  }
+
+  return data({ success: true });
 }
 
-//**********************************
 export default function EditBoxMQTT() {
-	const [mqttEnabled, setMqttEnabled] = useState(false)
-	const [mqttValid, setMqttValid] = useState(true)
-	const actionData = useActionData<typeof action>()
-
-	const mqttURLRef = React.useRef<HTMLInputElement>(null)
-	const mqttTopicRef = React.useRef<HTMLInputElement>(null)
-
-	React.useEffect(() => {
-		if (actionData) {
-			const hasErrors = Object.values(actionData?.errors).some(
-				(errorMessage) => errorMessage,
-			)
-
-			// ToDo
-			if (actionData.reset) {
-				// Do nothing for now
-			} else if (!hasErrors) {
-				if (actionData.isMqttValid) {
-					setMqttValid(true)
-					//* show conn. success msg
-					toast({
-						description: 'Successfully connected to mqtt url!',
-					})
-				} else {
-					setMqttValid(false)
-					mqttURLRef.current?.focus()
-				}
-			} else if (hasErrors && actionData?.errors?.mqttURL) {
-				mqttURLRef.current?.focus()
-			} else if (hasErrors && actionData?.errors?.mqttTopic) {
-				mqttTopicRef.current?.focus()
-			}
-		}
-	}, [actionData])
-
-	return (
-		<div className="grid grid-rows-1">
-			<div className="flex min-h-full items-center justify-center">
-				<div className="mx-auto w-full font-helvetica text-[14px]">
-					{/* Form */}
-					<Form method="post" noValidate>
-						{/* Heading */}
-						<div>
-							{/* Title */}
-							<div className="mt-2 flex justify-between">
-								<div>
-									<h1 className="text-4xl">MQTT</h1>
-								</div>
-								<div>
-									{/* Save button */}
-									<button
-										type="submit"
-										name="intent"
-										value="save"
-										className="h-12 w-12 rounded-full border-[1.5px] border-[#9b9494] hover:bg-[#e7e6e6]"
-									>
-										<Save className="mx-auto h-5 w-5 lg:h-7 lg:w-7" />
-									</button>
-								</div>
-							</div>
-						</div>
-
-						{/* divider */}
-						<hr className="my-3 mt-6 h-px border-0 bg-[#dcdada] dark:bg-gray-700" />
-
-						<div className="my-5 rounded border border-[#faebcc] bg-[#fcf8e3] p-4 text-[#8a6d3b]">
-							<p>
-								openSenseMap offers a{' '}
-								<a
-									href="http://mqtt.org/"
-									className="cursor-pointer text-[#4eaf47]"
-								>
-									MQTT{' '}
-								</a>{' '}
-								client for connecting to public brokers. Documentation for the
-								parameters is provided{' '}
-								<a
-									href="https://docs.opensensemap.org/#api-Boxes-postNewBox"
-									className="cursor-pointer text-[#4eaf47]"
-								>
-									in the docs.{' '}
-								</a>
-								Please note that it's only possible to receive measurements
-								through MQTT.
-							</p>
-						</div>
-
-						<div className="my-6 flex items-center space-x-2">
-							<Checkbox
-								name="enableMQTTcb"
-								onCheckedChange={() => setMqttEnabled(!mqttEnabled)}
-							/>
-							<label
-								htmlFor="terms"
-								className="cursor-pointer text-base font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
-							>
-								Enable MQTT
-							</label>
-						</div>
-
-						{/* MQTT URL */}
-						<div className="my-2">
-							<label
-								htmlFor="name"
-								className="txt-base block font-bold tracking-normal"
-							>
-								Url*
-							</label>
-
-							<div className="mt-1">
-								<input
-									id="mqttURL"
-									required
-									autoFocus={true}
-									name="mqttURL"
-									type="text"
-									ref={mqttURLRef}
-									className="w-full rounded border border-gray-200 px-2 py-1 text-base disabled:cursor-not-allowed disabled:bg-[#eee]"
-									disabled={!mqttEnabled}
-								/>
-								{actionData?.errors?.mqttURL && (
-									<div className="pt-1 text-[#FF0000]" id="mqttURL-error">
-										{actionData.errors.mqttURL}
-									</div>
-								)}
-
-								{!mqttValid && (
-									<div className="pt-1 text-[#FF0000]" id="mqttURL-error">
-										Entered mqtt url is not valid, please try again with a valid
-										one.
-									</div>
-								)}
-							</div>
-						</div>
-
-						{/* MQTT Topic */}
-						<div className="my-2">
-							<label
-								htmlFor="mqttTopic"
-								className="txt-base block font-bold tracking-normal"
-							>
-								Topic*
-							</label>
-
-							<div className="mt-1">
-								<input
-									id="mqttTopic"
-									required
-									autoFocus={true}
-									name="mqttTopic"
-									type="text"
-									ref={mqttTopicRef}
-									className="w-full rounded border border-gray-200 px-2 py-1 text-base disabled:cursor-not-allowed disabled:bg-[#eee]"
-									disabled={!mqttEnabled}
-								/>
-								{actionData?.errors?.mqttTopic && (
-									<div className="pt-1 text-[#FF0000]" id="mqttTopic-error">
-										{actionData.errors.mqttTopic}
-									</div>
-								)}
-							</div>
-						</div>
-
-						{/* MQTT Message format */}
-						<div className="my-4">
-							<label
-								htmlFor="mqttTopic"
-								className="txt-base block font-bold tracking-normal"
-							>
-								Message format*
-							</label>
-							<div className="mt-1">
-								<RadioGroup
-									defaultValue="json"
-									disabled={!mqttEnabled}
-									className="disabled:cursor-not-allowed"
-								>
-									<div className="flex items-center space-x-2">
-										<RadioGroupItem value="json" id="r1" />
-										<Label htmlFor="r1">json</Label>
-									</div>
-									<div className="flex items-center space-x-2">
-										<RadioGroupItem value="csv" id="r2" />
-										<Label htmlFor="r2">csv</Label>
-									</div>
-								</RadioGroup>
-							</div>
-						</div>
-
-						{/* MQTT Decoding options */}
-						<div className="my-2">
-							<label
-								htmlFor="mqttDecode"
-								className="txt-base block font-bold tracking-normal"
-							>
-								Decoding options
-							</label>
-
-							<div className="mt-1">
-								<input
-									id="mqttDecode"
-									autoFocus={true}
-									name="mqttDecode"
-									type="text"
-									className="w-full rounded border border-gray-200 px-2 py-1 text-base disabled:cursor-not-allowed disabled:bg-[#eee]"
-									disabled={!mqttEnabled}
-								/>
-							</div>
-						</div>
-
-						{/* MQTT Decoding options */}
-						<div>
-							<label
-								htmlFor="mqttConn"
-								className="txt-base block font-bold tracking-normal"
-							>
-								Connection options
-							</label>
-
-							<div className="mt-1">
-								<input
-									id="mqttConn"
-									name="mqttConn"
-									type="text"
-									className="w-full rounded border border-gray-200 px-2 py-1 text-base disabled:cursor-not-allowed disabled:bg-[#eee]"
-									disabled={!mqttEnabled}
-								/>
-							</div>
-						</div>
-					</Form>
-				</div>
-			</div>
-		</div>
-	)
+  const loaderData = useLoaderData<typeof loader>();
+
+  if (!loaderData) {
+    throw new Error("Loader data missing");
+  }
+
+  const { schema, uiSchema, integration } = loaderData;
+
+
+  const [formData, setFormData] = React.useState(() => {
+    if (!integration) {
+      return {
+        enabled: false,
+        messageFormat: "json",
+      };
+    }
+
+    return {
+      enabled: integration.enabled,
+      url: integration.url,
+      topic: integration.topic,
+      messageFormat: integration.messageFormat,
+      decodeOptions: integration.decodeOptions,
+      connectionOptions: integration.connectionOptions,
+    };
+  });
+  const fetcher = useFetcher();
+
+
+  React.useEffect(() => {
+    if (fetcher.data?.success) {
+      toast({ description: "MQTT configuration saved successfully!" });
+    }
+  }, [fetcher.data]);
+
+  const handleSubmit = async ({ formData: newFormData }: any) => {
+  await fetcher.submit(
+    { mqttConfig: JSON.stringify(newFormData) },
+    { method: "post" }
+  );
+};
+
+  return (
+      <div className="mx-auto max-w-xl">
+      <h1 className="text-4xl mb-4">MQTT</h1>
+
+        <Form
+          widgets={{CheckboxWidget}}
+          schema={schema}
+          uiSchema={uiSchema}
+          formData={formData}
+          validator={validator}
+          templates={{ FieldTemplate, BaseInputTemplate }}
+          onChange={(e: any) => setFormData(e.formData)}
+          onSubmit={handleSubmit}
+        >
+          <button
+            type="submit"
+            className="mt-4 h-12 w-12 rounded-full border"
+          >
+            <Save className="mx-auto h-6 w-6" />
+          </button>
+        </Form>
+    </div>
+  );
 }
 
 export function ErrorBoundary() {
diff --git a/app/routes/device.$deviceId.edit.tsx b/app/routes/device.$deviceId.edit.tsx
index c221fd4d..1ac4a5c3 100644
--- a/app/routes/device.$deviceId.edit.tsx
+++ b/app/routes/device.$deviceId.edit.tsx
@@ -2,40 +2,36 @@
 import * as ToastPrimitive from '@radix-ui/react-toast'
 import { clsx } from 'clsx'
 import {
-	ArrowRightLeft,
-	Lock,
-	MapPin,
-	FileText,
-	Wifi,
-	Sheet,
-	Cpu,
-	ArrowLeft,
-	UploadCloud,
-	NotepadText,
-} from 'lucide-react'
-import { useState } from 'react'
-import {
-	redirect,
-	Link,
-	Outlet,
-	useParams,
-	type LoaderFunctionArgs,
-} from 'react-router'
-import ErrorMessage from '~/components/error-message'
-import { EditDviceSidebarNav } from '~/components/mydevices/edit-device/edit-device-sidebar-nav'
-import { NavBar } from '~/components/nav-bar'
-import { Separator } from '~/components/ui/separator'
-import { getUserId } from '~/utils/session.server'
+  ArrowRightLeft,
+  Lock,
+  MapPin,
+  FileText,
+  Wifi,
+  Sheet,
+  Cpu,
+  ArrowLeft,
+  UploadCloud,
+  NotepadText,
+} from "lucide-react";
+import { useState } from "react";
+import { redirect , Link, Outlet, useParams, type LoaderFunctionArgs, useLoaderData  } from "react-router";
+import ErrorMessage from "~/components/error-message";
+import { EditDviceSidebarNav } from "~/components/mydevices/edit-device/edit-device-sidebar-nav";
+import { NavBar } from "~/components/nav-bar";
+import { Separator } from "~/components/ui/separator";
+import { getLucideIcon } from "~/lib/lucide-icon-map";
+import { getIntegrations } from "~/models/integration.server";
+import { getUserId } from "~/utils/session.server";
 
 //*****************************************************
-export async function loader({ request, params }: LoaderFunctionArgs) {
-	//* if user is not logged in, redirect to home
-	const userId = await getUserId(request)
-	if (!userId) return redirect('/')
-
-	const deviceID = params.deviceId
+export async function loader({ request }: LoaderFunctionArgs) {
+  //* if user is not logged in, redirect to home
+  const userId = await getUserId(request);
+  if (!userId) return redirect("/");
 
-	return { DevieID: deviceID }
+  return {
+    integrations: await getIntegrations(),
+  };
 }
 
 //*****************************************************
@@ -45,55 +41,40 @@ export async function action() {
 
 //**********************************
 export default function EditBox() {
-	//* Toast notification when device info is updated
-	const [toastOpen, setToastOpen] = useState(false)
-
-	// Get deviceId from route path
-	const { deviceId } = useParams()
-
-	const sidebarNavItems = [
-		{
-			title: 'General',
-			href: `/device/${deviceId}/edit/general`,
-			icon: Sheet,
-		},
-		{
-			title: 'Sensors',
-			href: `/device/${deviceId}/edit/sensors`,
-			icon: Cpu,
-		},
-		{
-			title: 'Location',
-			href: `/device/${deviceId}/edit/location`,
-			icon: MapPin,
-		},
-		{ title: 'Logs', href: `/device/${deviceId}/edit/logs`, icon: NotepadText },
-		{
-			title: 'Security',
-			href: `/device/${deviceId}/edit/security`,
-			icon: Lock,
-		},
-		{
-			title: 'Script',
-			href: `/device/${deviceId}/edit/script`,
-			icon: FileText,
-		},
-		{
-			title: 'MQTT',
-			href: `/device/${deviceId}/edit/mqtt`,
-			icon: Wifi,
-		},
-		{
-			title: 'TTN',
-			href: `/device/${deviceId}/edit/ttn`,
-			icon: UploadCloud,
-		},
-		{
-			title: 'Transfer',
-			href: `/device/${deviceId}/edit/transfer`,
-			icon: ArrowRightLeft,
-		},
-	]
+  const [toastOpen, setToastOpen] = useState(false);
+
+  const { integrations } = useLoaderData<typeof loader>();
+
+  const { deviceId } = useParams();
+
+  const staticNavItems = [
+    { title: "General", href: `/device/${deviceId}/edit/general`, icon: Sheet },
+    { title: "Sensors", href: `/device/${deviceId}/edit/sensors`, icon: Cpu },
+    { title: "Location", href: `/device/${deviceId}/edit/location`, icon: MapPin },
+    { title: "Logs", href: `/device/${deviceId}/edit/logs`, icon: NotepadText },
+    { title: "Security", href: `/device/${deviceId}/edit/security`, icon: Lock },
+    { title: "Script", href: `/device/${deviceId}/edit/script`, icon: FileText },
+  ];
+
+  const integrationItems = integrations.map((intg) => {
+  const Icon = getLucideIcon(intg.icon);
+
+    return {
+      title: intg.name,
+      href: `/device/${deviceId}/edit/${intg.slug}`,
+      icon: Icon,
+    };
+  });
+
+  const sidebarNavItems = [
+    ...staticNavItems,
+    ...integrationItems,
+    {
+      title: "Transfer",
+      href: `/device/${deviceId}/edit/transfer`,
+      icon: ArrowRightLeft,
+    },
+  ];
 
 	return (
 		<div className="space-y-6 px-10 pb-16 font-helvetica">
diff --git a/app/routes/device.$deviceId.edit.ttn.tsx b/app/routes/device.$deviceId.edit.ttn.tsx
index ce83ba49..da3a006c 100644
--- a/app/routes/device.$deviceId.edit.ttn.tsx
+++ b/app/routes/device.$deviceId.edit.ttn.tsx
@@ -1,180 +1,199 @@
-import { Save } from 'lucide-react'
-import { type LoaderFunctionArgs, redirect, Form } from 'react-router'
-import ErrorMessage from '~/components/error-message'
-import { getUserId } from '~/utils/session.server'
+import Form from "@rjsf/core";
+import validator from "@rjsf/validator-ajv8";
+import { Save } from "lucide-react";
+import React from "react";
+import { data, redirect, useFetcher, useLoaderData, type ActionFunctionArgs, type LoaderFunctionArgs } from "react-router";
+import ErrorMessage from "~/components/error-message";
+import { CheckboxWidget } from "~/components/rjsf/checkboxWidget";
+import { FieldTemplate } from "~/components/rjsf/fieldTemplate";
+import { BaseInputTemplate } from "~/components/rjsf/inputTemplate";
+import { toast } from "~/components/ui/use-toast";
+import { getUserId } from "~/utils/session.server";
 
 //*****************************************************
-export async function loader({ request }: LoaderFunctionArgs) {
-	//* if user is not logged in, redirect to home
-	const userId = await getUserId(request)
-	if (!userId) return redirect('/')
-
-	return ''
+export async function loader({ request, params }: LoaderFunctionArgs) {
+  const userId = await getUserId(request);
+  if (!userId) return redirect("/");
+  
+  const { deviceId } = params;
+
+  try {
+    const headers = {
+      "x-service-key": process.env.TTN_SERVICE_KEY!,
+    };
+    
+    const [schemaRes, integrationRes] = await Promise.all([
+      fetch(`${process.env.TTN_SERVICE_URL}/integrations/schema/ttn`, { headers }),
+      fetch(`${process.env.TTN_SERVICE_URL}/integrations/${deviceId}`, { headers }),
+    ]);
+
+    if (!schemaRes.ok) {
+      throw new Response("Failed to load TTN schema", { status: 500 });
+    }
+
+    const schemaData = await schemaRes.json();
+
+    let integration = null;
+    if (integrationRes.ok) {
+      integration = await integrationRes.json();
+    }
+
+    return {
+      schema: schemaData.schema,
+      uiSchema: schemaData.uiSchema,
+      integration,
+    };
+  } catch (error) {
+    console.error("Error loading TTN integration:", error);
+    throw new Response("Failed to load TTN integration", { status: 500 });
+  }
 }
 
-//*****************************************************
-export async function action() {
-	return ''
+export async function action({ request, params }: ActionFunctionArgs) {
+  const { deviceId } = params;
+  
+  const formData = await request.formData();
+  const ttnConfigStr = formData.get("ttnConfig");
+  
+  if (!ttnConfigStr) {
+    return data({ error: "No TTN config provided" }, { status: 400 });
+  }
+
+  const ttnConfig = JSON.parse(ttnConfigStr.toString());
+  
+  const serviceUrl = process.env.TTN_SERVICE_URL;
+  const serviceKey = process.env.TTN_SERVICE_KEY;
+
+  if (!serviceUrl || !serviceKey) {
+    throw new Error("TTN service env vars are not configured");
+  }
+
+  // Delete integration if disabled
+  if (!ttnConfig.enabled) {
+    await fetch(`${serviceUrl}/integrations/${deviceId}`, {
+      method: 'DELETE',
+      headers: { 'x-service-key': serviceKey }
+    });
+    return data({ success: true });
+  }
+
+  // Create or update integration
+  const response = await fetch(`${serviceUrl}/integrations/${deviceId}`, {
+    method: 'PUT',
+    headers: { 
+      'Content-Type': 'application/json',
+      'x-service-key': serviceKey
+    },
+    body: JSON.stringify({
+      devId: ttnConfig.devId,
+      appId: ttnConfig.appId,
+      profile: ttnConfig.profile,
+      port: ttnConfig.port,
+      decodeOptions: ttnConfig.decodeOptions,
+    })
+  });
+
+  if (!response.ok) {
+    const error = await response.json();
+    return data({ 
+      error: error.error || error.details || 'Failed to save configuration' 
+    }, { status: response.status });
+  }
+
+  return data({ success: true });
 }
 
-//**********************************
 export default function EditBoxTTN() {
-	return (
-		<div className="grid grid-rows-1">
-			<div className="flex min-h-full items-center justify-center">
-				<div className="mx-auto w-full font-helvetica text-[14px]">
-					{/* Form */}
-					<Form method="post" noValidate>
-						{/* Heading */}
-						<div>
-							{/* Title */}
-							<div className="mt-2 flex justify-between">
-								<div>
-									<h1 className="text-4xl">TheThingsNetwork - TTN</h1>
-								</div>
-								<div>
-									{/* Save button */}
-									<button
-										name="intent"
-										value="save"
-										className="h-12 w-12 rounded-full border-[1.5px] border-[#9b9494] hover:bg-[#e7e6e6]"
-									>
-										<Save className="mx-auto h-5 w-5 lg:h-7 lg:w-7" />
-									</button>
-								</div>
-							</div>
-						</div>
-
-						{/* divider */}
-						<hr className="my-3 mt-6 h-px border-0 bg-[#dcdada] dark:bg-gray-700" />
-
-						<div className="my-5 rounded border border-[#faebcc] bg-[#fcf8e3] p-4 text-[#8a6d3b]">
-							<p>
-								openSenseMap offers an integration with{' '}
-								<a
-									href="https://www.thethingsnetwork.org/"
-									className="cursor-pointer text-[#4eaf47]"
-								>
-									TheThingsNetwork.{' '}
-								</a>
-								Documentation for the parameters is provided{' '}
-								<a
-									href="https://github.com/sensebox/ttn-osem-integration"
-									className="cursor-pointer text-[#4eaf47]"
-								>
-									on GitHub
-								</a>
-							</p>
-						</div>
-
-						{/* Decoding Profile */}
-						<div>
-							<label
-								htmlFor="decProfile"
-								className="txt-base block font-bold tracking-normal"
-							>
-								Decoding Profile
-							</label>
-
-							<div className="mt-1">
-								<select
-									id="decProfile"
-									name="decProfile"
-									className="w-full appearance-auto rounded border border-gray-200 px-2 py-1.5 text-base"
-								>
-									<option value="senseBox/home">senseBox:home</option>
-									<option value="lora-serialization">LoRa serialization</option>
-									<option value="json">JSON</option>
-									<option value="cayenne-lpp">Cayenne LPP (beta)</option>
-								</select>
-							</div>
-						</div>
-
-						{/* TTN Application ID */}
-						<div className="my-3">
-							<label
-								htmlFor="ttnAppID"
-								className="txt-base block font-bold tracking-normal"
-							>
-								TTN Application ID
-							</label>
-
-							<div className="mt-1">
-								<input
-									id="ttnAppID"
-									autoFocus={true}
-									name="ttnAppID"
-									type="text"
-									className="w-full rounded border border-gray-200 px-2 py-1 text-base"
-								/>
-							</div>
-						</div>
-
-						{/* TTN Device ID */}
-						<div className="my-3">
-							<label
-								htmlFor="ttnDeID"
-								className="txt-base block font-bold tracking-normal"
-							>
-								TTN Device ID
-							</label>
-
-							<div className="mt-1">
-								<input
-									id="ttnDeID"
-									autoFocus={true}
-									name="ttnDeID"
-									type="text"
-									className="w-full rounded border border-gray-200 px-2 py-1 text-base"
-								/>
-							</div>
-						</div>
-
-						{/* Decoding Options */}
-						<div className="my-2">
-							<label
-								htmlFor="decOptions"
-								className="txt-base block font-bold tracking-normal"
-							>
-								Decoding Options
-							</label>
-
-							<div className="mt-1">
-								<textarea
-									id="decOptions"
-									name="decOptions"
-									disabled
-									className="w-full rounded border border-gray-200 px-2 py-1 text-base disabled:cursor-not-allowed disabled:bg-[#eee]"
-								/>
-							</div>
-						</div>
-
-						{/* Port */}
-						<div className="my-3">
-							<label
-								htmlFor="port"
-								className="txt-base block font-bold tracking-normal"
-							>
-								Port (optional)
-							</label>
-
-							<div className="mt-1">
-								<input
-									id="port"
-									autoFocus={true}
-									name="port"
-									type="number"
-									className="w-full rounded border border-gray-200 px-2 py-1 text-base"
-									min={1}
-									max={65535}
-								/>
-							</div>
-						</div>
-					</Form>
-				</div>
-			</div>
-		</div>
-	)
+  const loaderData = useLoaderData<typeof loader>();
+
+  if (!loaderData) {
+    throw new Error("Loader data missing");
+  }
+
+  const { schema, uiSchema, integration } = loaderData;
+
+  const [formData, setFormData] = React.useState(() => {
+    if (!integration) {
+      return {
+        enabled: false,
+        profile: "json",
+        decodeOptions: [{}],
+      };
+    }
+
+    return {
+      enabled: integration.enabled,
+      devId: integration.devId,
+      appId: integration.appId,
+      profile: integration.profile,
+      port: integration.port,
+      decodeOptions: integration.decodeOptions,
+    };
+  });
+
+  const fetcher = useFetcher();
+
+  React.useEffect(() => {
+    if (fetcher.data?.success) {
+      toast({ description: "TTN configuration saved successfully!" });
+    }
+  }, [fetcher.data]);
+
+  const handleSubmit = async ({ formData: newFormData }: any) => {
+    await fetcher.submit(
+      { ttnConfig: JSON.stringify(newFormData) },
+      { method: "post" }
+    );
+  };
+
+  return (
+    <div className="mx-auto max-w-xl">
+      <h1 className="text-4xl mb-4">TheThingsNetwork - TTN</h1>
+
+      <div className="my-5 rounded border border-[#faebcc] bg-[#fcf8e3] p-4 text-[#8a6d3b]">
+        <p>
+          openSenseMap offers an integration with{" "}
+          <a
+            href="https://www.thethingsnetwork.org/"
+            className="cursor-pointer text-[#4eaf47]"
+          >
+            TheThingsNetwork.{" "}
+          </a>
+          Documentation for the parameters is provided{" "}
+          <a
+            href="https://github.com/sensebox/ttn-osem-integration"
+            className="cursor-pointer text-[#4eaf47]"
+          >
+            on GitHub
+          </a>
+        </p>
+      </div>
+
+      <Form
+        widgets={{ CheckboxWidget }}
+        schema={schema}
+        uiSchema={uiSchema}
+        formData={formData}
+        validator={validator}
+        templates={{ FieldTemplate, BaseInputTemplate  }}
+        onChange={(e: any) => setFormData(e.formData)}
+        onSubmit={handleSubmit}
+      >
+        <button
+          type="submit"
+          className="mt-4 h-12 w-12 rounded-full border"
+        >
+          <Save className="mx-auto h-6 w-6" />
+        </button>
+      </Form>
+
+      {fetcher.data?.error && (
+        <div className="mt-4 rounded border border-red-300 bg-red-50 p-4 text-red-800">
+          {fetcher.data.error}
+        </div>
+      )}
+    </div>
+  );
 }
 
 export function ErrorBoundary() {
@@ -183,4 +202,4 @@ export function ErrorBoundary() {
 			<ErrorMessage />
 		</div>
 	)
-}
+}
\ No newline at end of file
diff --git a/app/routes/device.new.tsx b/app/routes/device.new.tsx
index 0d294659..79439f0a 100644
--- a/app/routes/device.new.tsx
+++ b/app/routes/device.new.tsx
@@ -1,12 +1,9 @@
-import {
-	type ActionFunctionArgs,
-	redirect,
-	type LoaderFunctionArgs,
-} from 'react-router'
-import ValidationStepperForm from '~/components/device/new/new-device-stepper'
-import { NavBar } from '~/components/nav-bar'
-import { createDevice } from '~/models/device.server'
-import { getUser, getUserId } from '~/utils/session.server'
+import { type ActionFunctionArgs, redirect, type LoaderFunctionArgs } from "react-router";
+import ValidationStepperForm from "~/components/device/new/new-device-stepper";
+import { NavBar } from "~/components/nav-bar";
+import { createDevice } from "~/models/device.server";
+import { getIntegrations } from "~/models/integration.server";
+import { getUser, getUserId } from "~/utils/session.server";
 
 export async function loader({ request }: LoaderFunctionArgs) {
 	const user = await getUser(request)
@@ -27,44 +24,90 @@ export async function action({ request }: ActionFunctionArgs) {
 			throw new Error('User is not authenticated.')
 		}
 
-		const data = JSON.parse(rawData)
-
-		const selectedSensors = data['sensor-selection'].selectedSensors
-
-		const devicePayload = {
-			name: data['general-info'].name,
-			exposure: data['general-info'].exposure,
-			expiresAt: data['general-info'].temporaryExpirationDate,
-			tags:
-				data['general-info'].tags?.map((tag: { value: string }) => tag.value) ||
-				[],
-			latitude: data.location.latitude,
-			longitude: data.location.longitude,
-
-			...(data['device-selection'].model !== 'custom' && {
-				model: data['device-selection'].model,
-
-				sensorTemplates: selectedSensors.map((sensor: any) =>
-					sensor.sensorType.toLowerCase(),
-				),
-			}),
-
-			...(data['device-selection'].model === 'custom' && {
-				sensors: selectedSensors.map((sensor: any) => ({
-					title: sensor.title,
-					sensorType: sensor.sensorType,
-					unit: sensor.unit,
-					icon: sensor.icon,
-				})),
-			}),
-
-			mqttEnabled: data.advanced.mqttEnabled ?? false,
-			ttnEnabled: data.advanced.ttnEnabled ?? false,
-		}
+    const data = JSON.parse(rawData);
+    const advanced = data.advanced;
+
+    // Map sensors from nested objects
+    const sensors = data["sensor-selection"].selectedSensors.map(
+      (sensor: any) => ({
+        title: sensor.title,
+        sensorType: sensor.sensorType,
+        unit: sensor.unit,
+      })
+    );
+
+    // Construct device payload 
+    const devicePayload = {
+      name: data["general-info"].name,
+      exposure: data["general-info"].exposure,
+      expiresAt: data["general-info"].temporaryExpirationDate,
+      tags:
+        data["general-info"].tags?.map((tag: { value: string }) => tag.value) ||
+        [],
+      latitude: data.location.latitude,
+      longitude: data.location.longitude,
+      model: data["device-selection"].model,
+      sensors,
+    };
+
+    // -----------------------------
+    // Create device in OpenSenseMap
+    // -----------------------------
+    const newDevice = await createDevice(devicePayload, userId);
+    const deviceId = newDevice.id;
+
+    const integrations = await getIntegrations();
+
+    for (const intg of integrations) {
+      const enabledKey = `${intg.slug}Enabled`; 
+      const configKey = `${intg.slug}Config`; 
+      
+      const config = advanced[configKey];
+        if (!config) {
+          console.warn(`${intg.name} is enabled but no config provided`);
+          continue;
+        }
+
+      // Check if this integration is enabled in the form data
+      if (!advanced?.[enabledKey] || !advanced?.[configKey]) {
+        continue; 
+      }
 
-		// Call server function
-		const newDevice = await createDevice(devicePayload, userId)
-		console.log('🚀 ~ New Device Created:', newDevice)
+      try {
+
+        const serviceKey = process.env[intg.serviceKeyEnvVar];
+        
+        if (!serviceKey) {
+          throw new Error(
+            `Service key env var '${intg.serviceKeyEnvVar}' not configured`
+          );
+        }
+
+        const response = await fetch(
+          `${intg.serviceUrl}/integrations/${deviceId}`,
+          {
+            method: "PUT",
+            headers: {
+              "Content-Type": "application/json",
+              "x-service-key": serviceKey,
+            },
+            body: JSON.stringify(advanced[configKey]),
+          }
+        );
+
+        if (!response.ok) {
+          const errText = await response.text();
+          throw new Error(`Failed: ${response.status} - ${errText}`);
+        }
+
+        console.log(`✅ Created ${intg.name} integration for device ${deviceId}`);
+      } catch (error) {
+        console.error(`Failed to create ${intg.name} integration:`, error);
+        
+      }
+    }
+
+    console.log("🚀 Device Created:", newDevice.id);
 
 		return redirect('/profile/me')
 	} catch (error) {
@@ -73,6 +116,7 @@ export async function action({ request }: ActionFunctionArgs) {
 	}
 }
 
+
 export default function NewDevice() {
 	return (
 		<div className="flex h-screen flex-col">
diff --git a/app/routes/docs.tsx b/app/routes/docs.tsx
index c4e784ea..5b3aeb62 100644
--- a/app/routes/docs.tsx
+++ b/app/routes/docs.tsx
@@ -1,33 +1,51 @@
-// app/routes/docs.tsx
-import { useLoaderData } from 'react-router'
-import SwaggerUI from 'swagger-ui-react'
-import 'swagger-ui-react/swagger-ui.css'
-import { openapiSpecification } from '~/lib/openapi' // Direct import
-
-// In production, use the pre-built file
-const isProduction = process.env.NODE_ENV === 'production'
+import { useLoaderData } from "react-router";
+import SwaggerUI from "swagger-ui-react";
+import "swagger-ui-react/swagger-ui.css";
 
 export const loader = async () => {
-	if (isProduction) {
-		const spec = await import('../../public/openapi.json')
-		return Response.json(spec)
-	}
-	return Response.json(openapiSpecification())
-}
+  if (process.env.NODE_ENV === "production") {
+    const spec = await import("../../public/openapi.json");
+    return Response.json({ spec });
+  }
+
+  const { combinedOpenapiSpecification } = await import(
+    "~/lib/openapi.combined"
+  );
+
+  return Response.json({
+    spec: combinedOpenapiSpecification(),
+  });
+};
+
 
 export default function ApiDocumentation() {
-	const spec = useLoaderData()
-	return (
-		<main>
-			<div className="flex items-center justify-center p-3">
-				<img
-					src="./openSenseMap_API.png"
-					alt="API Image"
-					height={350}
-					width={350}
-				/>
-			</div>
-			<SwaggerUI spec={spec} />
-		</main>
-	)
+  const { spec } = useLoaderData<typeof loader>();
+
+  return (
+    <main className="container mx-auto p-6">
+      <div className="flex justify-center p-3">
+        <img
+          src="./openSenseMap_API.png"
+          alt="API Image"
+          width={350}
+        />
+      </div>
+
+      {/* Optional manual TOC */}
+      <div className="mb-6 flex gap-4 justify-center">
+        <a href="#public-api" className="text-blue-600 hover:underline">
+          Public API
+        </a>
+        <a href="#integration-api" className="text-green-600 hover:underline">
+          Integration API
+        </a>
+      </div>
+
+      <SwaggerUI
+        spec={spec}
+        docExpansion="list"
+        defaultModelsExpandDepth={1}
+      />
+    </main>
+  );
 }
diff --git a/app/schema/integration.ts b/app/schema/integration.ts
new file mode 100644
index 00000000..777d5086
--- /dev/null
+++ b/app/schema/integration.ts
@@ -0,0 +1,21 @@
+import { createId } from '@paralleldrive/cuid2'
+import { InferSelectModel } from 'drizzle-orm';
+import { integer, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+
+export const integration = pgTable('integration', {
+  id: text('id')
+		.primaryKey()
+		.notNull()
+		.$defaultFn(() => createId()),
+  name: text('name').notNull(),           
+  slug: text('slug').notNull().unique(), 
+  serviceUrl: text('service_url').notNull(),
+  serviceKeyEnvVar: text('service_key_env_var').notNull(),
+  schemaPath: text('schema_path').notNull(),
+  icon: text('icon'), //name of lucide icon , pascal case! 
+  description: text('description'),
+  order: integer('order').default(0),
+  createdAt: timestamp('created_at').defaultNow(),
+});
+
+export type Integration = InferSelectModel<typeof integration>
diff --git a/app/utils/env.server.ts b/app/utils/env.server.ts
index 29900327..88290a0f 100644
--- a/app/utils/env.server.ts
+++ b/app/utils/env.server.ts
@@ -1,23 +1,25 @@
 import { z } from 'zod'
 
 const schema = z.object({
-	NODE_ENV: z.enum(['production', 'development', 'test'] as const),
-	DATABASE_URL: z.string(),
-	PG_CLIENT_SSL: z.string(),
-	SESSION_SECRET: z.string(),
-	MAPBOX_GEOCODING_API: z.string().url(),
-	MAPBOX_ACCESS_TOKEN: z.string(),
-	OSEM_API_URL: z.string().url(),
-	DIRECTUS_URL: z.string().url(),
-	SENSORWIKI_API_URL: z.string().url(),
-	MYBADGES_API_URL: z.string().url(),
-	MYBADGES_URL: z.string().url(),
-	MYBADGES_SERVERADMIN_USERNAME: z.string(),
-	MYBADGES_SERVERADMIN_PASSWORD: z.string(),
-	MYBADGES_ISSUERID_OSEM: z.string(),
-	MYBADGES_CLIENT_ID: z.string(),
-	MYBADGES_CLIENT_SECRET: z.string(),
-})
+  NODE_ENV: z.enum(["production", "development", "test"] as const),
+  DATABASE_URL: z.string(),
+  PG_CLIENT_SSL: z.string(),
+  SESSION_SECRET: z.string(),
+  MAPBOX_GEOCODING_API: z.string().url(),
+  MAPBOX_ACCESS_TOKEN: z.string(),
+  OSEM_API_URL: z.string().url(),
+  DIRECTUS_URL: z.string().url(),
+  SENSORWIKI_API_URL: z.string().url(),
+  MYBADGES_API_URL: z.string().url(),
+  MYBADGES_URL: z.string().url(),
+  MYBADGES_SERVERADMIN_USERNAME: z.string(),
+  MYBADGES_SERVERADMIN_PASSWORD: z.string(),
+  MYBADGES_ISSUERID_OSEM: z.string(),
+  MYBADGES_CLIENT_ID: z.string(),
+  MYBADGES_CLIENT_SECRET: z.string(),
+  MQTT_SERVICE_URL: z.string(),
+  MQTT_SERVICE_KEY: z.string()
+});
 
 declare global {
 	namespace NodeJS {
@@ -37,15 +39,16 @@ export function init() {
 }
 
 export function getEnv() {
-	return {
-		MODE: process.env.NODE_ENV,
-		MAPBOX_GEOCODING_API: process.env.MAPBOX_GEOCODING_API,
-		MAPBOX_ACCESS_TOKEN: process.env.MAPBOX_ACCESS_TOKEN,
-		DIRECTUS_URL: process.env.DIRECTUS_URL,
-		MYBADGES_API_URL: process.env.MYBADGES_API_URL,
-		MYBADGES_URL: process.env.MYBADGES_URL,
-		SENSORWIKI_API_URL: process.env.SENSORWIKI_API_URL,
-	}
+  return {
+    MODE: process.env.NODE_ENV,
+    MAPBOX_GEOCODING_API: process.env.MAPBOX_GEOCODING_API,
+    MAPBOX_ACCESS_TOKEN: process.env.MAPBOX_ACCESS_TOKEN,
+    DIRECTUS_URL: process.env.DIRECTUS_URL,
+    MYBADGES_API_URL: process.env.MYBADGES_API_URL,
+    MYBADGES_URL: process.env.MYBADGES_URL,
+    SENSORWIKI_API_URL: process.env.SENSORWIKI_API_URL,
+    MQTT_SERVICE_URL: process.env.MQTT_SERVICE_URL,
+  };
 }
 
 type ENV = ReturnType<typeof getEnv>
diff --git a/db/seed-integrations.ts b/db/seed-integrations.ts
new file mode 100644
index 00000000..d75ec271
--- /dev/null
+++ b/db/seed-integrations.ts
@@ -0,0 +1,44 @@
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+import { integration } from "../app/schema/integration";
+import { envDBSchema } from "./env-schema";
+
+console.log(`🔌 setting up drizzle client to ${envDBSchema.DATABASE_URL}`);
+
+const queryClient = postgres(envDBSchema.DATABASE_URL, {
+  max: 1,
+  ssl: envDBSchema.PG_CLIENT_SSL === "true" ? true : false,
+});
+const client = drizzle(queryClient);
+
+async function seed() {
+    await client.insert(integration).values([
+  {
+    name: 'MQTT',
+    slug: 'mqtt',
+    serviceUrl: process.env.MQTT_SERVICE_URL!,
+    serviceKeyEnvVar: 'MQTT_SERVICE_KEY',
+    schemaPath: '/integrations/schema/mqtt',
+    icon: 'message-square-text',
+    order: 1,
+  },
+  {
+    name: 'The Things Network',
+    slug: 'ttn',
+    serviceUrl: process.env.TTN_SERVICE_URL!,
+    serviceKeyEnvVar: 'TTN_SERVICE_KEY',
+    schemaPath: '/integrations/schema/ttn',
+    icon: 'antenna',
+    order: 2,
+  },
+]);
+}
+
+seed()
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  })
+  .finally(async () => {
+    await queryClient.end({ timeout: 5 });
+  });
diff --git a/package-lock.json b/package-lock.json
index 73734ad5..37f5fc73 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -45,6 +45,9 @@
         "@react-router/express": "^7.12.0",
         "@react-router/node": "^7.12.0",
         "@react-router/serve": "^7.12.0",
+        "@rjsf/core": "^6.2.5",
+        "@rjsf/utils": "^6.2.5",
+        "@rjsf/validator-ajv8": "^6.2.5",
         "@stepperize/react": "^5.1.6",
         "@tanstack/react-table": "^8.21.3",
         "@turf/bbox": "^7.2.0",
@@ -178,6 +181,7 @@
         "jsdom": "^26.1.0",
         "msw": "^2.10.2",
         "npm-run-all": "^4.1.5",
+        "openapi-types": "^12.1.3",
         "postcss": "^8.5.6",
         "postcss-cli": "^11.0.1",
         "prettier": "3.6.2",
@@ -7576,6 +7580,28 @@
         }
       }
     },
+    "node_modules/@react-router/dev/node_modules/@react-router/node": {
+      "version": "7.12.0",
+      "resolved": "https://registry.npmjs.org/@react-router/node/-/node-7.12.0.tgz",
+      "integrity": "sha512-o/t10Cse4LK8kFefqJ8JjC6Ng6YuKD2I87S2AiJs17YAYtXU5W731ZqB73AWyCDd2G14R0dSuqXiASRNK/xLjg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@mjackson/node-fetch-server": "^0.2.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "react-router": "7.12.0",
+        "typescript": "^5.1.0"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/@react-router/dev/node_modules/jsesc": {
       "version": "3.0.2",
       "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.0.2.tgz",
@@ -7590,19 +7616,18 @@
       }
     },
     "node_modules/@react-router/express": {
-      "version": "7.12.0",
-      "resolved": "https://registry.npmjs.org/@react-router/express/-/express-7.12.0.tgz",
-      "integrity": "sha512-uAK+zF93M6XauGeXLh/UBh+3HrwiA/9lUS+eChjQ0a5FzjLpsc6ciUqF5oHh3lwWzLU7u7tj4qoeucUn6SInTw==",
-      "license": "MIT",
+      "version": "7.13.0",
+      "resolved": "https://registry.npmjs.org/@react-router/express/-/express-7.13.0.tgz",
+      "integrity": "sha512-9az5P7sjbfxb0l4TtS5tlyV2tI8ZY4dWeuddxK2JLtgWwe+MGGSEO62fY87PidmgTqpQXguT6iyR5RXP9gJucA==",
       "dependencies": {
-        "@react-router/node": "7.12.0"
+        "@react-router/node": "7.13.0"
       },
       "engines": {
         "node": ">=20.0.0"
       },
       "peerDependencies": {
         "express": "^4.17.1 || ^5",
-        "react-router": "7.12.0",
+        "react-router": "7.13.0",
         "typescript": "^5.1.0"
       },
       "peerDependenciesMeta": {
@@ -7660,10 +7685,9 @@
       }
     },
     "node_modules/@react-router/node": {
-      "version": "7.12.0",
-      "resolved": "https://registry.npmjs.org/@react-router/node/-/node-7.12.0.tgz",
-      "integrity": "sha512-o/t10Cse4LK8kFefqJ8JjC6Ng6YuKD2I87S2AiJs17YAYtXU5W731ZqB73AWyCDd2G14R0dSuqXiASRNK/xLjg==",
-      "license": "MIT",
+      "version": "7.13.0",
+      "resolved": "https://registry.npmjs.org/@react-router/node/-/node-7.13.0.tgz",
+      "integrity": "sha512-Mhr3fAou19oc/S93tKMIBHwCPfqLpWyWM/m0NWd3pJh/wZin8/9KhAdjwxhYbXw1TrTBZBLDENa35uZ+Y7oh3A==",
       "dependencies": {
         "@mjackson/node-fetch-server": "^0.2.0"
       },
@@ -7671,7 +7695,7 @@
         "node": ">=20.0.0"
       },
       "peerDependencies": {
-        "react-router": "7.12.0",
+        "react-router": "7.13.0",
         "typescript": "^5.1.0"
       },
       "peerDependenciesMeta": {
@@ -7681,14 +7705,13 @@
       }
     },
     "node_modules/@react-router/serve": {
-      "version": "7.12.0",
-      "resolved": "https://registry.npmjs.org/@react-router/serve/-/serve-7.12.0.tgz",
-      "integrity": "sha512-j1ltgU7s3wAwOosZ5oxgHSsmVyK706gY/yIs8qVmC239wQ3zr3eqaXk3TVVLMeRy+eDgPNmgc6oNJv2o328VgA==",
-      "license": "MIT",
+      "version": "7.13.0",
+      "resolved": "https://registry.npmjs.org/@react-router/serve/-/serve-7.13.0.tgz",
+      "integrity": "sha512-bgpA3YdUvuSAQa0vRM9xeZaBsglgUvxsVCUqdJpxF87ZF9pT5uoAITrWYd1soDB8jSksnH3btJEXHasvG7cikA==",
       "dependencies": {
         "@mjackson/node-fetch-server": "^0.2.0",
-        "@react-router/express": "7.12.0",
-        "@react-router/node": "7.12.0",
+        "@react-router/express": "7.13.0",
+        "@react-router/node": "7.13.0",
         "compression": "^1.8.1",
         "express": "^4.19.2",
         "get-port": "5.1.1",
@@ -7702,7 +7725,7 @@
         "node": ">=20.0.0"
       },
       "peerDependencies": {
-        "react-router": "7.12.0"
+        "react-router": "7.13.0"
       }
     },
     "node_modules/@react-router/serve/node_modules/get-port": {
@@ -7864,6 +7887,101 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@rjsf/core": {
+      "version": "6.2.5",
+      "resolved": "https://registry.npmjs.org/@rjsf/core/-/core-6.2.5.tgz",
+      "integrity": "sha512-k/2aAKj9IY7JBcnPrYv7frgHkfK0KsS7h8PgPW14GJREh+X5EX/icrypcQu5ge/Ggbwi+90plJll07YiRV/lFg==",
+      "dependencies": {
+        "lodash": "^4.17.21",
+        "lodash-es": "^4.17.21",
+        "markdown-to-jsx": "^8.0.0",
+        "prop-types": "^15.8.1"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "peerDependencies": {
+        "@rjsf/utils": "^6.2.x",
+        "react": ">=18"
+      }
+    },
+    "node_modules/@rjsf/utils": {
+      "version": "6.2.5",
+      "resolved": "https://registry.npmjs.org/@rjsf/utils/-/utils-6.2.5.tgz",
+      "integrity": "sha512-29SvRuY3gKyAHUUnIiJiAF/mTnokgrE7XqUXMj+CZK+sGcmAegwhlnQMJgLQciTodMwTwOaDyV1Fxc47VKTHFw==",
+      "dependencies": {
+        "@x0k/json-schema-merge": "^1.0.2",
+        "fast-uri": "^3.1.0",
+        "jsonpointer": "^5.0.1",
+        "lodash": "^4.17.21",
+        "lodash-es": "^4.17.21",
+        "react-is": "^18.3.1"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "peerDependencies": {
+        "react": ">=18"
+      }
+    },
+    "node_modules/@rjsf/utils/node_modules/react-is": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",
+      "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg=="
+    },
+    "node_modules/@rjsf/validator-ajv8": {
+      "version": "6.2.5",
+      "resolved": "https://registry.npmjs.org/@rjsf/validator-ajv8/-/validator-ajv8-6.2.5.tgz",
+      "integrity": "sha512-+yLhFRuT2aY91KiUujhUKg8SyTBrUuQP3QAFINeGi+RljA3S+NQN56oeCaNdz9X+35+Sdy6jqmxy/0Q2K+K9vQ==",
+      "dependencies": {
+        "ajv": "^8.17.1",
+        "ajv-formats": "^2.1.1",
+        "lodash": "^4.17.21",
+        "lodash-es": "^4.17.21"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "peerDependencies": {
+        "@rjsf/utils": "^6.2.x"
+      }
+    },
+    "node_modules/@rjsf/validator-ajv8/node_modules/ajv": {
+      "version": "8.17.1",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
+      "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.3",
+        "fast-uri": "^3.0.1",
+        "json-schema-traverse": "^1.0.0",
+        "require-from-string": "^2.0.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/@rjsf/validator-ajv8/node_modules/ajv-formats": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-2.1.1.tgz",
+      "integrity": "sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==",
+      "dependencies": {
+        "ajv": "^8.0.0"
+      },
+      "peerDependencies": {
+        "ajv": "^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "ajv": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rjsf/validator-ajv8/node_modules/json-schema-traverse": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="
+    },
     "node_modules/@rolldown/pluginutils": {
       "version": "1.0.0-beta.47",
       "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.47.tgz",
@@ -11223,6 +11341,14 @@
         "url": "https://opencollective.com/vitest"
       }
     },
+    "node_modules/@x0k/json-schema-merge": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@x0k/json-schema-merge/-/json-schema-merge-1.0.2.tgz",
+      "integrity": "sha512-1734qiJHNX3+cJGDMMw2yz7R+7kpbAtl5NdPs1c/0gO5kYT6s4dMbLXiIfpZNsOYhGZI3aH7FWrj4Zxz7epXNg==",
+      "dependencies": {
+        "@types/json-schema": "^7.0.15"
+      }
+    },
     "node_modules/abort-controller": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
@@ -16067,7 +16193,6 @@
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
       "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/fast-glob": {
@@ -16137,7 +16262,6 @@
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz",
       "integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==",
-      "dev": true,
       "funding": [
         {
           "type": "github",
@@ -18558,6 +18682,14 @@
         "graceful-fs": "^4.1.6"
       }
     },
+    "node_modules/jsonpointer": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/jsonpointer/-/jsonpointer-5.0.1.tgz",
+      "integrity": "sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/jsonwebtoken": {
       "version": "9.0.2",
       "resolved": "https://registry.npmjs.org/jsonwebtoken/-/jsonwebtoken-9.0.2.tgz",
@@ -19120,6 +19252,22 @@
         "url": "https://github.com/fb55/entities?sponsor=1"
       }
     },
+    "node_modules/markdown-to-jsx": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/markdown-to-jsx/-/markdown-to-jsx-8.0.0.tgz",
+      "integrity": "sha512-hWEaRxeCDjes1CVUQqU+Ov0mCqBqkGhLKjL98KdbwHSgEWZZSJQeGlJQatVfeZ3RaxrfTrZZ3eczl2dhp5c/pA==",
+      "engines": {
+        "node": ">= 10"
+      },
+      "peerDependencies": {
+        "react": ">= 0.14.0"
+      },
+      "peerDependenciesMeta": {
+        "react": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/marked": {
       "version": "15.0.12",
       "resolved": "https://registry.npmjs.org/marked/-/marked-15.0.12.tgz",
@@ -21020,6 +21168,12 @@
         "node": ">=12.20.0"
       }
     },
+    "node_modules/openapi-types": {
+      "version": "12.1.3",
+      "resolved": "https://registry.npmjs.org/openapi-types/-/openapi-types-12.1.3.tgz",
+      "integrity": "sha512-N4YtSYJqghVu4iek2ZUvcN/0aqH1kRDuNqzcycDxhOUpg7GdvLa2F3DgS6yBNhInhv2r/6I0Flkn7CqL8+nIcw==",
+      "dev": true
+    },
     "node_modules/optionator": {
       "version": "0.9.4",
       "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
@@ -24533,7 +24687,6 @@
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
       "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
diff --git a/package.json b/package.json
index e0239f24..62038dff 100644
--- a/package.json
+++ b/package.json
@@ -20,6 +20,7 @@
     "db:studio": "drizzle-kit studio",
     "db:setup": "npm run db:generate && npm run db:migrate",
     "db:seed": "tsx ./db/seed.ts",
+    "db:seed-integrations": "tsx ./db/seed-integrations.ts",
     "email:dev": "email dev",
     "components": "npx shadcn-ui",
     "format": "prettier --write .",
@@ -67,6 +68,9 @@
     "@react-router/express": "^7.12.0",
     "@react-router/node": "^7.12.0",
     "@react-router/serve": "^7.12.0",
+    "@rjsf/core": "^6.2.5",
+    "@rjsf/utils": "^6.2.5",
+    "@rjsf/validator-ajv8": "^6.2.5",
     "@stepperize/react": "^5.1.6",
     "@tanstack/react-table": "^8.21.3",
     "@turf/bbox": "^7.2.0",
@@ -200,6 +204,7 @@
     "jsdom": "^26.1.0",
     "msw": "^2.10.2",
     "npm-run-all": "^4.1.5",
+    "openapi-types": "^12.1.3",
     "postcss": "^8.5.6",
     "postcss-cli": "^11.0.1",
     "prettier": "3.6.2",
diff --git a/public/integration-api.json b/public/integration-api.json
new file mode 100644
index 00000000..e28747d5
--- /dev/null
+++ b/public/integration-api.json
@@ -0,0 +1,410 @@
+{
+  "openapi": "3.0.0",
+  "info": {
+    "title": "OpenSenseMap Integration API",
+    "version": "1.0.0",
+    "description": "\n# Building OpenSenseMap Integrations\n\nOpenSenseMap uses a plugin architecture for integrations. Any service implementing this specification can connect devices from any platform or protocol to OpenSenseMap.\n\n## Architecture\n\n```\nOpenSenseMap (Main App)\n    ↓ Registers & calls via HTTP\nYour Integration Service\n    ↓ Receives data from\nYour Protocol (MQTT/LoRa/etc.)\n```\n\n## Required Endpoints\n\nYour integration service MUST implement these endpoints:\n\n1. **GET /integrations/:deviceId** - Get integration config\n2. **PUT /integrations/:deviceId** - Create/update integration config\n3. **DELETE /integrations/:deviceId** - Delete integration config\n4. **GET /integrations/schema/{name}** - Return JSON Schema for config form\n5. **GET /health** - Health check\n\n## Authentication\n\nAll endpoints (except /health) require `x-service-key` header.\n\n## Forwarding Measurements\n\nAfter processing data, POST measurements to OpenSenseMap:\n\n**Endpoint:** `POST /api/boxes/:deviceId/:sensorId`\n\n**Headers:**\n- `Content-Type: application/json`\n- `x-service-key`: Your service key (provided by OpenSenseMap)\n\n**Body:**\n```json\n{\n  \"value\": 23.5,\n  \"createdAt\": \"2026-02-06T10:00:00Z\",\n  \"location\": {\n    \"lng\": 7.628,\n    \"lat\": 51.963,\n    \"height\": 100\n  }\n}\n```\n\n## Reference Implementations\n\n- [MQTT Integration](https://github.com/opensensemap/mqtt-integration)\n- [TTN Integration](https://github.com/opensensemap/ttn-integration)\n\n## Registration\n\nTo register your integration, contact OpenSenseMap admins with:\n- Service name and description\n- Service URL and authentication key\n- Icon (Lucide icon name)\n- JSON Schema endpoint path\n      "
+  },
+  "servers": [
+    {
+      "url": "https://your-integration-service.com",
+      "description": "Your integration microservice"
+    }
+  ],
+  "components": {
+    "securitySchemes": {
+      "ServiceKey": {
+        "type": "apiKey",
+        "in": "header",
+        "name": "x-service-key",
+        "description": "Service authentication key configured in OpenSenseMap"
+      }
+    },
+    "parameters": {
+      "DeviceId": {
+        "name": "deviceId",
+        "in": "path",
+        "required": true,
+        "schema": {
+          "type": "string"
+        },
+        "description": "OpenSenseMap device ID",
+        "example": "cm65qexample123"
+      }
+    },
+    "schemas": {
+      "IntegrationConfig": {
+        "type": "object",
+        "description": "Integration configuration (schema varies by integration type)",
+        "additionalProperties": true,
+        "example": {
+          "id": "intg_123",
+          "deviceId": "cm65qexample123",
+          "enabled": true,
+          "url": "mqtt://broker.example.com",
+          "topic": "sensors/data",
+          "messageFormat": "json"
+        }
+      },
+      "JsonSchema": {
+        "type": "object",
+        "description": "JSON Schema (draft-07) for dynamic form generation",
+        "properties": {
+          "schema": {
+            "type": "object",
+            "description": "JSON Schema definition"
+          },
+          "uiSchema": {
+            "type": "object",
+            "description": "React JSON Schema Form UI Schema"
+          }
+        },
+        "required": [
+          "schema"
+        ]
+      },
+      "Error": {
+        "type": "object",
+        "properties": {
+          "error": {
+            "type": "string"
+          },
+          "details": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          }
+        }
+      }
+    },
+    "responses": {
+      "NotFound": {
+        "description": "Resource not found",
+        "content": {
+          "application/json": {
+            "schema": {
+              "$ref": "#/components/schemas/Error"
+            },
+            "example": {
+              "error": "Integration not found"
+            }
+          }
+        }
+      },
+      "ValidationError": {
+        "description": "Validation failed",
+        "content": {
+          "application/json": {
+            "schema": {
+              "$ref": "#/components/schemas/Error"
+            },
+            "example": {
+              "error": "Validation failed",
+              "details": [
+                "url is required and must be a string",
+                "topic is required and must be a string"
+              ]
+            }
+          }
+        }
+      },
+      "Unauthorized": {
+        "description": "Unauthorized - invalid or missing service key",
+        "content": {
+          "application/json": {
+            "schema": {
+              "$ref": "#/components/schemas/Error"
+            },
+            "example": {
+              "error": "Unauthorized"
+            }
+          }
+        }
+      },
+      "InternalError": {
+        "description": "Internal server error",
+        "content": {
+          "application/json": {
+            "schema": {
+              "$ref": "#/components/schemas/Error"
+            },
+            "example": {
+              "error": "Internal server error"
+            }
+          }
+        }
+      }
+    }
+  },
+  "security": [
+    {
+      "ServiceKey": []
+    }
+  ],
+  "tags": [
+    {
+      "name": "Integration Management",
+      "description": "CRUD operations for integration configurations"
+    },
+    {
+      "name": "Schema",
+      "description": "JSON Schema for dynamic form generation"
+    },
+    {
+      "name": "Health",
+      "description": "Service health check"
+    }
+  ],
+  "paths": {
+    "/integrations/{deviceId}": {
+      "get": {
+        "summary": "Get integration configuration for a device",
+        "operationId": "getIntegration",
+        "tags": [
+          "Integration Management"
+        ],
+        "parameters": [
+          {
+            "$ref": "#/components/parameters/DeviceId"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Integration configuration",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/IntegrationConfig"
+                }
+              }
+            }
+          },
+          "401": {
+            "$ref": "#/components/responses/Unauthorized"
+          },
+          "404": {
+            "$ref": "#/components/responses/NotFound"
+          },
+          "500": {
+            "$ref": "#/components/responses/InternalError"
+          }
+        }
+      },
+      "put": {
+        "summary": "Create or update integration configuration",
+        "operationId": "createOrUpdateIntegration",
+        "tags": [
+          "Integration Management"
+        ],
+        "parameters": [
+          {
+            "$ref": "#/components/parameters/DeviceId"
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "description": "Configuration specific to your integration type",
+                "additionalProperties": true
+              },
+              "examples": {
+                "mqtt": {
+                  "summary": "MQTT Integration",
+                  "value": {
+                    "url": "mqtt://broker.example.com:1883",
+                    "topic": "sensors/temperature",
+                    "messageFormat": "json",
+                    "connectionOptions": {
+                      "username": "user",
+                      "password": "pass"
+                    }
+                  }
+                },
+                "ttn": {
+                  "summary": "TTN Integration",
+                  "value": {
+                    "devId": "my-device",
+                    "appId": "my-app",
+                    "profile": "cayenne-lpp"
+                  }
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Integration updated",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/IntegrationConfig"
+                }
+              }
+            }
+          },
+          "201": {
+            "description": "Integration created",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/IntegrationConfig"
+                }
+              }
+            }
+          },
+          "400": {
+            "$ref": "#/components/responses/ValidationError"
+          },
+          "401": {
+            "$ref": "#/components/responses/Unauthorized"
+          },
+          "500": {
+            "$ref": "#/components/responses/InternalError"
+          }
+        }
+      },
+      "delete": {
+        "summary": "Delete integration configuration",
+        "operationId": "deleteIntegration",
+        "tags": [
+          "Integration Management"
+        ],
+        "parameters": [
+          {
+            "$ref": "#/components/parameters/DeviceId"
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "Integration deleted successfully"
+          },
+          "401": {
+            "$ref": "#/components/responses/Unauthorized"
+          },
+          "404": {
+            "$ref": "#/components/responses/NotFound"
+          },
+          "500": {
+            "$ref": "#/components/responses/InternalError"
+          }
+        }
+      }
+    },
+    "/integrations/schema/{integrationName}": {
+      "get": {
+        "summary": "Get JSON Schema for integration configuration form",
+        "operationId": "getIntegrationSchema",
+        "tags": [
+          "Schema"
+        ],
+        "parameters": [
+          {
+            "name": "integrationName",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "example": "mqtt"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "JSON Schema for dynamic form generation",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/JsonSchema"
+                },
+                "examples": {
+                  "mqtt": {
+                    "summary": "MQTT Schema Example",
+                    "value": {
+                      "schema": {
+                        "type": "object",
+                        "required": [
+                          "url",
+                          "topic",
+                          "messageFormat"
+                        ],
+                        "properties": {
+                          "url": {
+                            "type": "string",
+                            "title": "Broker URL",
+                            "pattern": "^(mqtt|mqtts|ws|wss)://.+"
+                          },
+                          "topic": {
+                            "type": "string",
+                            "title": "Topic"
+                          },
+                          "messageFormat": {
+                            "type": "string",
+                            "title": "Message Format",
+                            "enum": [
+                              "json",
+                              "csv"
+                            ]
+                          }
+                        }
+                      },
+                      "uiSchema": {
+                        "ui:order": [
+                          "url",
+                          "topic",
+                          "messageFormat"
+                        ]
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "401": {
+            "$ref": "#/components/responses/Unauthorized"
+          },
+          "500": {
+            "$ref": "#/components/responses/InternalError"
+          }
+        }
+      }
+    },
+    "/health": {
+      "get": {
+        "summary": "Health check endpoint",
+        "operationId": "healthCheck",
+        "tags": [
+          "Health"
+        ],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "Service is healthy",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "status": {
+                      "type": "string",
+                      "example": "healthy"
+                    },
+                    "timestamp": {
+                      "type": "string",
+                      "format": "date-time"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/public/openapi.json b/public/openapi.json
index 09c805a2..a20ba152 100644
--- a/public/openapi.json
+++ b/public/openapi.json
@@ -1,18 +1,18 @@
 {
   "openapi": "3.0.0",
   "info": {
-    "title": "",
+    "title": "OpenSenseMap API",
     "version": "1.0.0",
-    "description": "## Documentation of the routes and methods to manage users, stations (also called boxes or senseBoxes), and measurements in the openSenseMap API. You can find the API running at [https://opensensemap.org/api/](https://opensensemap.org/api/).\n# Timestamps\n\n## Please note that the API handles every timestamp in Coordinated universal time (UTC) time zone. Timestamps in parameters should be in RFC 3339 notation.\n\n**Timestamp without Milliseconds:**\n\n```\n2018-02-01T23:18:02Z\n```\n\n**Timestamp with Milliseconds:**\n\n```\n2018-02-01T23:18:02.412Z\n```\n\n# IDs\n\n## All stations and sensors of stations receive a unique public identifier. These identifiers are exactly 24 character long and only contain digits and characters a to f.\n\n**Example:**\n\n```\n5a8d1c25bc2d41001927a265\n```\n\n# Parameters\n\n## Only if noted otherwise, all requests assume the payload encoded as JSON with `Content-type: application/json` header. Parameters prepended with a colon (`:`) are parameters which should be specified through the URL.\n\n# Source code and Licenses\n\n## You can find the whole source code of the API at GitHub in the [sensebox/openSenseMap-API](https://github.com/sensebox/openSenseMap-API) repository. You can obtain the code under the MIT License.\n\n## The data obtainable through the openSenseMap API at [https://opensensemap.org/api/](https://opensensemap.org/api/) is licensed under the [Public Domain Dedication and License 1.0](https://opendatacommons.org/licenses/pddl/summary/).\n\n## If there is something unclear or there is a mistake in this documentation please open an [issue](https://github.com/openSenseMap/frontend/issues/new) in the GitHub repository."
+    "description": "\n# OpenSenseMap API Documentation\n\nUse the links below or the sidebar to navigate.\n\n- Public API\n- Integration API\n        "
   },
   "servers": [
-    {
-      "url": "https://opensensemap.org/api",
-      "description": "Production server"
-    },
     {
       "url": "http://localhost:3000",
       "description": "Development server"
+    },
+    {
+      "url": "https://opensensemap.org/api",
+      "description": "Production server"
     }
   ],
   "components": {
@@ -32,6 +32,406 @@
           "2018-02-01T23:18:02.412Z"
         ]
       },
+      "Box": {
+        "type": "object",
+        "description": "Box/Device object",
+        "properties": {
+          "_id": {
+            "type": "string",
+            "description": "Unique box identifier",
+            "example": "clx1234567890abcdef"
+          },
+          "name": {
+            "type": "string",
+            "description": "Box name",
+            "example": "My Weather Station"
+          },
+          "description": {
+            "type": "string",
+            "description": "Box description",
+            "example": "A weather monitoring station"
+          },
+          "image": {
+            "type": "string",
+            "format": "uri",
+            "description": "Box image URL",
+            "example": "https://example.com/image.jpg"
+          },
+          "link": {
+            "type": "string",
+            "format": "uri",
+            "description": "Box website link",
+            "example": "https://example.com"
+          },
+          "grouptag": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "Box group tags",
+            "example": [
+              "weather",
+              "outdoor"
+            ]
+          },
+          "exposure": {
+            "type": "string",
+            "enum": [
+              "indoor",
+              "outdoor",
+              "mobile",
+              "unknown"
+            ],
+            "description": "Box exposure type",
+            "example": "outdoor"
+          },
+          "model": {
+            "type": "string",
+            "enum": [
+              "homeV2Lora",
+              "homeV2Ethernet",
+              "homeV2Wifi",
+              "senseBox:Edu",
+              "luftdaten.info",
+              "Custom"
+            ],
+            "description": "Box model",
+            "example": "homeV2Wifi"
+          },
+          "latitude": {
+            "type": "number",
+            "description": "Box latitude",
+            "example": 52.520008
+          },
+          "longitude": {
+            "type": "number",
+            "description": "Box longitude",
+            "example": 13.404954
+          },
+          "useAuth": {
+            "type": "boolean",
+            "description": "Whether box requires authentication",
+            "example": true
+          },
+          "public": {
+            "type": "boolean",
+            "description": "Whether box is public",
+            "example": false
+          },
+          "status": {
+            "type": "string",
+            "enum": [
+              "active",
+              "inactive",
+              "old"
+            ],
+            "description": "Box status",
+            "example": "inactive"
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Box creation timestamp",
+            "example": "2024-01-15T10:30:00Z"
+          },
+          "updatedAt": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Box last update timestamp",
+            "example": "2024-01-15T10:30:00Z"
+          },
+          "expiresAt": {
+            "type": "string",
+            "format": "date-time",
+            "nullable": true,
+            "description": "Box expiration date",
+            "example": "2024-12-31T23:59:59Z"
+          },
+          "userId": {
+            "type": "string",
+            "description": "Owner user ID",
+            "example": "user_123456"
+          },
+          "sensorWikiModel": {
+            "type": "string",
+            "nullable": true,
+            "description": "Sensor Wiki model identifier",
+            "example": "homeV2Wifi"
+          },
+          "currentLocation": {
+            "type": "object",
+            "description": "Current location as GeoJSON Point",
+            "properties": {
+              "type": {
+                "type": "string",
+                "example": "Point"
+              },
+              "coordinates": {
+                "type": "array",
+                "items": {
+                  "type": "number"
+                },
+                "example": [
+                  13.404954,
+                  52.520008
+                ]
+              },
+              "timestamp": {
+                "type": "string",
+                "format": "date-time",
+                "example": "2023-01-01T00:00:00.000Z"
+              }
+            }
+          },
+          "lastMeasurementAt": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Last measurement timestamp",
+            "example": "2023-01-01T00:00:00.000Z"
+          },
+          "loc": {
+            "type": "array",
+            "description": "Location history as GeoJSON features",
+            "items": {
+              "type": "object",
+              "properties": {
+                "type": {
+                  "type": "string",
+                  "example": "Feature"
+                },
+                "geometry": {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "example": "Point"
+                    },
+                    "coordinates": {
+                      "type": "array",
+                      "items": {
+                        "type": "number"
+                      },
+                      "example": [
+                        13.404954,
+                        52.520008
+                      ]
+                    },
+                    "timestamp": {
+                      "type": "string",
+                      "format": "date-time",
+                      "example": "2023-01-01T00:00:00.000Z"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "integrations": {
+            "type": "object",
+            "description": "Box integrations",
+            "properties": {
+              "mqtt": {
+                "type": "object",
+                "properties": {
+                  "enabled": {
+                    "type": "boolean",
+                    "example": false
+                  }
+                }
+              }
+            }
+          },
+          "sensors": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "_id": {
+                  "type": "string",
+                  "description": "Sensor ID",
+                  "example": "sensor123"
+                },
+                "title": {
+                  "type": "string",
+                  "description": "Sensor title",
+                  "example": "Temperature"
+                },
+                "unit": {
+                  "type": "string",
+                  "description": "Sensor unit",
+                  "example": "°C"
+                },
+                "sensorType": {
+                  "type": "string",
+                  "description": "Sensor type",
+                  "example": "HDC1080"
+                },
+                "lastMeasurement": {
+                  "type": "object",
+                  "description": "Last measurement data",
+                  "properties": {
+                    "createdAt": {
+                      "type": "string",
+                      "format": "date-time",
+                      "example": "2023-01-01T00:00:00.000Z"
+                    },
+                    "value": {
+                      "type": "string",
+                      "example": "25.13"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "Device": {
+        "type": "object",
+        "required": [
+          "id",
+          "latitude",
+          "longitude"
+        ],
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "Unique device identifier",
+            "example": "device-123"
+          },
+          "name": {
+            "type": "string",
+            "description": "Device name",
+            "example": "Temperature Sensor A1"
+          },
+          "latitude": {
+            "type": "number",
+            "format": "float",
+            "description": "Device latitude coordinate",
+            "example": 52.52
+          },
+          "longitude": {
+            "type": "number",
+            "format": "float",
+            "description": "Device longitude coordinate",
+            "example": 13.405
+          },
+          "phenomenon": {
+            "type": "string",
+            "description": "Type of phenomenon measured",
+            "example": "temperature"
+          },
+          "grouptag": {
+            "type": "string",
+            "description": "Group tag for device categorization",
+            "example": "outdoor-sensors"
+          },
+          "exposure": {
+            "type": "string",
+            "description": "Device exposure type",
+            "example": "outdoor"
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Device creation timestamp",
+            "example": "2023-05-15T10:00:00Z"
+          },
+          "updatedAt": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Device last update timestamp",
+            "example": "2023-05-15T12:00:00Z"
+          }
+        }
+      },
+      "GeoJSONFeatureCollection": {
+        "type": "object",
+        "required": [
+          "type",
+          "features"
+        ],
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": [
+              "FeatureCollection"
+            ],
+            "example": "FeatureCollection"
+          },
+          "features": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/GeoJSONFeature"
+            }
+          }
+        }
+      },
+      "GeoJSONFeature": {
+        "type": "object",
+        "required": [
+          "type",
+          "geometry",
+          "properties"
+        ],
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": [
+              "Feature"
+            ],
+            "example": "Feature"
+          },
+          "geometry": {
+            "$ref": "#/components/schemas/GeoJSONPoint"
+          },
+          "properties": {
+            "$ref": "#/components/schemas/Device"
+          }
+        }
+      },
+      "GeoJSONPoint": {
+        "type": "object",
+        "required": [
+          "type",
+          "coordinates"
+        ],
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": [
+              "Point"
+            ],
+            "example": "Point"
+          },
+          "coordinates": {
+            "type": "array",
+            "items": {
+              "type": "number"
+            },
+            "minItems": 2,
+            "maxItems": 2,
+            "description": "Longitude and latitude coordinates",
+            "example": [
+              13.405,
+              52.52
+            ]
+          }
+        }
+      },
+      "ErrorResponse": {
+        "type": "object",
+        "required": [
+          "error"
+        ],
+        "properties": {
+          "error": {
+            "type": "string",
+            "description": "Error message",
+            "example": "Failed to fetch devices"
+          }
+        }
+      },
       "Sensor": {
         "type": "object",
         "properties": {
@@ -82,6 +482,130 @@
             "example": 25.4
           }
         }
+      },
+      "User": {
+        "type": "object",
+        "description": "User information object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "Unique user identifier",
+            "example": "user_123456"
+          },
+          "email": {
+            "type": "string",
+            "format": "email",
+            "description": "User's email address",
+            "example": "john.doe@example.com"
+          },
+          "name": {
+            "type": "string",
+            "description": "User's display name",
+            "example": "John Doe"
+          },
+          "language": {
+            "type": "string",
+            "description": "User's preferred language",
+            "example": "en_US",
+            "enum": [
+              "de_DE",
+              "en_US"
+            ]
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Account creation timestamp",
+            "example": "2025-06-18T10:30:00Z"
+          },
+          "updatedAt": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Last account update timestamp",
+            "example": "2025-06-18T10:30:00Z"
+          },
+          "username": {
+            "type": "string",
+            "description": "User's chosen username",
+            "example": "john_doe"
+          }
+        },
+        "required": [
+          "id",
+          "username",
+          "email",
+          "language"
+        ]
+      },
+      "ForbiddenError": {
+        "type": "object",
+        "properties": {
+          "code": {
+            "type": "string",
+            "example": "Forbidden"
+          },
+          "message": {
+            "type": "string",
+            "example": "Invalid JWT authorization. Please sign in to obtain new JWT."
+          }
+        }
+      },
+      "InternalServerError": {
+        "type": "object",
+        "properties": {
+          "error": {
+            "type": "string",
+            "example": "Internal Server Error"
+          },
+          "message": {
+            "type": "string",
+            "example": "The server was unable to complete your request. Please try again later."
+          }
+        }
+      },
+      "IntegrationConfig": {
+        "type": "object",
+        "description": "Integration configuration (schema varies by integration type)",
+        "additionalProperties": true,
+        "example": {
+          "id": "intg_123",
+          "deviceId": "cm65qexample123",
+          "enabled": true,
+          "url": "mqtt://broker.example.com",
+          "topic": "sensors/data",
+          "messageFormat": "json"
+        }
+      },
+      "JsonSchema": {
+        "type": "object",
+        "description": "JSON Schema (draft-07) for dynamic form generation",
+        "properties": {
+          "schema": {
+            "type": "object",
+            "description": "JSON Schema definition"
+          },
+          "uiSchema": {
+            "type": "object",
+            "description": "React JSON Schema Form UI Schema"
+          }
+        },
+        "required": [
+          "schema"
+        ]
+      },
+      "Error": {
+        "type": "object",
+        "properties": {
+          "error": {
+            "type": "string"
+          },
+          "details": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          }
+        }
       }
     },
     "parameters": {
@@ -101,6 +625,16 @@
           "$ref": "#/components/schemas/Timestamp"
         },
         "description": "Timestamp parameter in RFC 3339 format (UTC)"
+      },
+      "DeviceId": {
+        "name": "deviceId",
+        "in": "path",
+        "required": true,
+        "schema": {
+          "type": "string"
+        },
+        "description": "OpenSenseMap device ID",
+        "example": "cm65qexample123"
       }
     },
     "responses": {
@@ -125,79 +659,1719 @@
         "content": {
           "application/json": {
             "schema": {
-              "type": "object",
-              "properties": {
-                "error": {
-                  "type": "string",
-                  "example": "Resource not found"
-                }
-              }
+              "$ref": "#/components/schemas/Error"
+            },
+            "example": {
+              "error": "Integration not found"
             }
           }
         }
-      }
-    }
-  },
-  "paths": {
-    "/api/getsensors": {
-      "get": {
-        "tags": [
-          "Sensors"
-        ],
-        "summary": "Get sensors by device ID",
-        "description": "Returns a list of sensors associated with the specified device ID",
+      },
+      "ValidationError": {
+        "description": "Validation failed",
+        "content": {
+          "application/json": {
+            "schema": {
+              "$ref": "#/components/schemas/Error"
+            },
+            "example": {
+              "error": "Validation failed",
+              "details": [
+                "url is required and must be a string",
+                "topic is required and must be a string"
+              ]
+            }
+          }
+        }
+      },
+      "Unauthorized": {
+        "description": "Unauthorized - invalid or missing service key",
+        "content": {
+          "application/json": {
+            "schema": {
+              "$ref": "#/components/schemas/Error"
+            },
+            "example": {
+              "error": "Unauthorized"
+            }
+          }
+        }
+      },
+      "InternalError": {
+        "description": "Internal server error",
+        "content": {
+          "application/json": {
+            "schema": {
+              "$ref": "#/components/schemas/Error"
+            },
+            "example": {
+              "error": "Internal server error"
+            }
+          }
+        }
+      }
+    },
+    "securitySchemes": {
+      "bearerAuth": {
+        "type": "http",
+        "scheme": "bearer",
+        "bearerFormat": "JWT",
+        "description": "JWT token obtained from sign-in endpoint"
+      },
+      "ServiceKey": {
+        "type": "apiKey",
+        "in": "header",
+        "name": "x-service-key",
+        "description": "Service authentication key configured in OpenSenseMap"
+      }
+    }
+  },
+  "paths": {
+    "/boxes/{deviceId}/data/{sensorId}": {
+      "get": {
+        "tags": [
+          "Public · Sensors"
+        ],
+        "summary": "Get up to 10000 measurements from a sensor for a specific time frame",
+        "description": "Get up to 10000 measurements from a sensor for a specific time frame, parameters `from-date` and `to-date` are optional. If not set, the last 48 hours are used. The maximum time frame is 1 month. If `download=true` `Content-disposition` headers will be set. Allows for JSON or CSV format.",
+        "parameters": [
+          {
+            "in": "path",
+            "name": "deviceId",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "the ID of the senseBox you are referring to"
+          },
+          {
+            "in": "path",
+            "name": "sensorId",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "the ID of the sensor you are referring to"
+          },
+          {
+            "in": "query",
+            "name": "outliers",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "enum": [
+                "replace",
+                "mark"
+              ]
+            },
+            "description": "Specifying this parameter enables outlier calculation which adds a new field called `isOutlier` to the data. Possible values are \"mark\" and \"replace\"."
+          },
+          {
+            "in": "query",
+            "name": "outlier-window",
+            "required": false,
+            "schema": {
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 50,
+              "default": 15
+            },
+            "description": "Size of moving window used as base to calculate the outliers."
+          },
+          {
+            "in": "query",
+            "name": "from-date",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "description": "RFC3339Date",
+              "format": "date-time"
+            },
+            "description": "Beginning date of measurement data (default: 48 hours ago from now)"
+          },
+          {
+            "in": "query",
+            "name": "to-date",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "descrption": "TFC3339Date",
+              "format": "date-time"
+            },
+            "description": "End date of measurement data (default: now)"
+          },
+          {
+            "in": "query",
+            "name": "format",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "enum": [
+                "json",
+                "csv"
+              ],
+              "default": "json"
+            },
+            "description": "Can be 'json' (default) or 'csv' (default: json)"
+          },
+          {
+            "in": "query",
+            "name": "download",
+            "required": false,
+            "schema": {
+              "type": "boolean"
+            },
+            "description": "if specified, the api will set the `content-disposition` header thus forcing browsers to download instead of displaying. Is always true for format csv."
+          },
+          {
+            "in": "query",
+            "name": "delimiter",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "enum": [
+                "comma",
+                "semicolon"
+              ],
+              "default": "comma"
+            },
+            "description": "Only for csv: the delimiter for csv. Possible values: `semicolon`, `comma`. Per default a comma is used. Alternatively you can use separator as parameter name."
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "example": "[{\"sensor_id\":\"6649b23072c4c40007105953\",\"time\":\"2025-11-06 23:59:57.189+00\",\"value\":4.78,\"location_id\":\"5752066\"},{\"sensor_id\":\"6649b23072c4c40007105953\",\"time\":\"2025-11-06 23:57:06.03+00\",\"value\":4.13,\"location_id\":\"5752066\"}]"
+                }
+              },
+              "text/csv": {
+                "example": "createdAt,value 2023-09-29T08:06:13.254Z,6.38 2023-09-29T08:06:12.312Z,6.38 2023-09-29T08:06:11.513Z,6.38 2023-09-29T08:06:10.380Z,6.38 2023-09-29T08:06:09.569Z,6.38 2023-09-29T08:06:05.967Z,6.38"
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "error": {
+                      "type": "string"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "error": {
+                      "type": "string"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal Server Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "error": {
+                      "type": "string"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/boxes/{deviceId}/locations": {
+      "get": {
+        "tags": [
+          "Public · Boxes"
+        ],
+        "summary": "Get locations of a senseBox",
+        "description": "Get all locations of the specified senseBox ordered by date as an array of GeoJSON Points. If `format=geojson`, a GeoJSON linestring will be returned, with `properties.timestamps` being an array with the timestamp for each coordinate.",
         "parameters": [
+          {
+            "in": "path",
+            "name": "deviceId",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "the ID of the senseBox you are referring to"
+          },
+          {
+            "in": "query",
+            "name": "from-date",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "description": "RFC3339Date",
+              "format": "date-time"
+            },
+            "description": "Beginning date of measurement data (default: 48 hours ago from now)"
+          },
+          {
+            "in": "query",
+            "name": "to-date",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "descrption": "TFC3339Date",
+              "format": "date-time"
+            },
+            "description": "End date of measurement data (default: now)"
+          },
           {
             "in": "query",
+            "name": "format",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "enum": [
+                "json",
+                "geojson"
+              ],
+              "default": "json"
+            },
+            "description": "Can be 'json' (default) or 'geojson' (default: json)"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "example": "[{ \"coordinates\": [7.68123, 51.9123], \"type\": \"Point\", \"timestamp\": \"2017-07-27T12:00.000Z\"},{ \"coordinates\": [7.68223, 51.9433, 66.6], \"type\": \"Point\", \"timestamp\": \"2017-07-27T12:01.000Z\"},{ \"coordinates\": [7.68323, 51.9423], \"type\": \"Point\", \"timestamp\": \"2017-07-27T12:02.000Z\"}]"
+                }
+              },
+              "application/geojson": {
+                "example": ""
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "error": {
+                      "type": "string"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "error": {
+                      "type": "string"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal Server Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "error": {
+                      "type": "string"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/boxes/{deviceId}/sensors": {
+      "get": {
+        "tags": [
+          "Public · Sensors"
+        ],
+        "summary": "Get the latest measurements of all sensors of the specified senseBox.",
+        "parameters": [
+          {
+            "in": "path",
             "name": "deviceId",
             "required": true,
             "schema": {
               "type": "string"
             },
-            "description": "The ID of the device to fetch sensors for",
-            "example": "device-123"
+            "description": "the ID of the senseBox you are referring to"
+          },
+          {
+            "in": "query",
+            "name": "count",
+            "required": false,
+            "schema": {
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 100
+            },
+            "description": "Number of measurements to be retrieved for every sensor"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": null
+          }
+        }
+      }
+    },
+    "/api/boxes": {
+      "post": {
+        "tags": [
+          "Public · Boxes"
+        ],
+        "summary": "Create a new box",
+        "description": "Creates a new box/device with sensors",
+        "operationId": "createBox",
+        "security": [
+          {
+            "bearerAuth": []
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "required": [
+                  "name",
+                  "location"
+                ],
+                "properties": {
+                  "name": {
+                    "type": "string",
+                    "description": "Box name",
+                    "example": "trala"
+                  },
+                  "exposure": {
+                    "type": "string",
+                    "enum": [
+                      "indoor",
+                      "outdoor",
+                      "mobile",
+                      "unknown"
+                    ],
+                    "description": "Box exposure type",
+                    "example": "mobile"
+                  },
+                  "location": {
+                    "type": "array",
+                    "items": {
+                      "type": "number"
+                    },
+                    "minItems": 2,
+                    "maxItems": 2,
+                    "description": "Box location as [longitude, latitude]",
+                    "example": [
+                      -122.406417,
+                      37.785834
+                    ]
+                  },
+                  "grouptag": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    },
+                    "description": "Box group tags",
+                    "example": [
+                      "bike",
+                      "atrai",
+                      "arnsberg"
+                    ]
+                  },
+                  "model": {
+                    "type": "string",
+                    "enum": [
+                      "homeV2Lora",
+                      "homeV2Ethernet",
+                      "homeV2Wifi",
+                      "senseBox:Edu",
+                      "luftdaten.info",
+                      "Custom"
+                    ],
+                    "description": "Box model type",
+                    "example": "Custom"
+                  },
+                  "sensors": {
+                    "type": "array",
+                    "items": {
+                      "type": "object",
+                      "required": [
+                        "id",
+                        "title",
+                        "sensorType",
+                        "unit"
+                      ],
+                      "properties": {
+                        "id": {
+                          "type": "string",
+                          "description": "Sensor ID",
+                          "example": "0"
+                        },
+                        "icon": {
+                          "type": "string",
+                          "description": "Sensor icon",
+                          "example": "osem-thermometer"
+                        },
+                        "title": {
+                          "type": "string",
+                          "description": "Sensor title",
+                          "example": "Temperature"
+                        },
+                        "sensorType": {
+                          "type": "string",
+                          "description": "Sensor type",
+                          "example": "HDC1080"
+                        },
+                        "unit": {
+                          "type": "string",
+                          "description": "Sensor unit",
+                          "example": "°C"
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "201": {
+            "description": "Box created successfully",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Box"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad request - validation error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "code": {
+                      "type": "string",
+                      "example": "Bad Request"
+                    },
+                    "message": {
+                      "type": "string",
+                      "example": "Invalid request data"
+                    },
+                    "errors": {
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "403": {
+            "description": "Forbidden - invalid or missing JWT token",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "code": {
+                      "type": "string",
+                      "example": "Forbidden"
+                    },
+                    "message": {
+                      "type": "string",
+                      "example": "Invalid JWT authorization. Please sign in to obtain new JWT."
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "405": {
+            "description": "Method not allowed - only POST is supported",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Method Not Allowed"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal server error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "code": {
+                      "type": "string",
+                      "example": "Internal Server Error"
+                    },
+                    "message": {
+                      "type": "string",
+                      "example": "The server was unable to create the box. Please try again later."
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/device/{deviceId}": {
+      "get": {
+        "summary": "Get device by ID",
+        "description": "Retrieve a single device by their unique identifier",
+        "tags": [
+          "Public · Device"
+        ],
+        "parameters": [
+          {
+            "in": "path",
+            "name": "id",
+            "required": true,
+            "description": "Unique identifier of the user",
+            "schema": {
+              "type": "string",
+              "example": "12345"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Device retrieved successfully",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "id": {
+                      "type": "string",
+                      "example": "12345"
+                    },
+                    "name": {
+                      "type": "string",
+                      "example": "John Doe"
+                    },
+                    "email": {
+                      "type": "string",
+                      "example": "john.doe@example.com"
+                    },
+                    "createdAt": {
+                      "type": "string",
+                      "format": "date-time",
+                      "example": "2023-01-15T10:30:00Z"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Device ID is required",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "error": {
+                      "type": "string",
+                      "example": "Device ID is required."
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Device not found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "error": {
+                      "type": "string",
+                      "example": "Device not found"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal server error"
+          }
+        }
+      }
+    },
+    "/api/devices": {
+      "get": {
+        "tags": [
+          "Public · Devices"
+        ],
+        "summary": "Get devices with filtering options",
+        "description": "Retrieves devices based on various filter criteria. Supports both JSON and GeoJSON formats.",
+        "parameters": [
+          {
+            "name": "format",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "enum": [
+                "json",
+                "geojson"
+              ],
+              "default": "json"
+            },
+            "description": "Response format"
+          },
+          {
+            "name": "minimal",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "enum": [
+                true,
+                false
+              ],
+              "default": false
+            },
+            "description": "Return minimal device information"
+          },
+          {
+            "name": "full",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "enum": [
+                true,
+                false
+              ],
+              "default": false
+            },
+            "description": "Return full device information"
+          },
+          {
+            "name": "limit",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 20,
+              "default": 5
+            },
+            "description": "Maximum number of devices to return"
+          },
+          {
+            "name": "name",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "string"
+            },
+            "description": "Filter devices by name"
+          },
+          {
+            "name": "phenomenon",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "string"
+            },
+            "description": "Filter devices by phenomenon type"
+          },
+          {
+            "name": "fromDate",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "format": "date-time"
+            },
+            "description": "Filter devices from this date",
+            "example": "2023-05-15T10:00:00Z"
+          },
+          {
+            "name": "toDate",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "format": "date-time"
+            },
+            "description": "Filter devices to this date",
+            "example": "2023-05-15T12:00:00Z"
+          },
+          {
+            "name": "grouptag",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "string"
+            },
+            "description": "Filter devices by group tag"
+          },
+          {
+            "name": "exposure",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "string"
+            },
+            "description": "Filter devices by exposure type"
+          },
+          {
+            "name": "near",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "pattern": "^-?\\d+\\.?\\d*,-?\\d+\\.?\\d*$"
+            },
+            "description": "Find devices near coordinates (lat,lng)",
+            "example": "52.5200,13.4050"
+          },
+          {
+            "name": "maxDistance",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "number",
+              "default": 1000
+            },
+            "description": "Maximum distance in meters when using 'near' parameter"
+          },
+          {
+            "name": "bbox",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "pattern": "^-?\\d+\\.?\\d*,-?\\d+\\.?\\d*,-?\\d+\\.?\\d*,-?\\d+\\.?\\d*$"
+            },
+            "description": "Bounding box coordinates (swLng,swLat,neLng,neLat)",
+            "example": "13.2,52.4,13.6,52.6"
+          },
+          {
+            "name": "date",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "format": "date-time"
+            },
+            "description": "Specific date filter (TODO - not implemented)"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successfully retrieved devices",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "oneOf": [
+                    {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/components/schemas/Device"
+                      }
+                    },
+                    {
+                      "$ref": "#/components/schemas/GeoJSONFeatureCollection"
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Invalid request",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Invalid parameters",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                },
+                "examples": {
+                  "invalidFormat": {
+                    "summary": "Invalid format parameter",
+                    "value": {
+                      "error": "Failed to fetch devices"
+                    }
+                  },
+                  "invalidLimit": {
+                    "summary": "Invalid limit parameter",
+                    "value": {
+                      "error": "Limit must be at least 1"
+                    }
+                  },
+                  "exceedsLimit": {
+                    "summary": "Limit exceeds maximum",
+                    "value": {
+                      "error": "Limit should not exceed 20"
+                    }
+                  },
+                  "invalidNear": {
+                    "summary": "Invalid near parameter",
+                    "value": {
+                      "error": "Invalid 'near' parameter format. Expected: 'lat,lng'"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal server error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                },
+                "example": {
+                  "error": "Failed to fetch devices"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/getsensors": {
+      "get": {
+        "tags": [
+          "Public · Sensors"
+        ],
+        "summary": "Get sensors by device ID",
+        "description": "Returns a list of sensors associated with the specified device ID",
+        "parameters": [
+          {
+            "in": "query",
+            "name": "deviceId",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "The ID of the device to fetch sensors for",
+            "example": "device-123"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful operation",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/Sensor"
+                  }
+                },
+                "example": [
+                  {
+                    "id": "sensor-1",
+                    "name": "Temperature Sensor",
+                    "type": "temperature"
+                  },
+                  {
+                    "id": "sensor-2",
+                    "name": "Humidity Sensor",
+                    "type": "humidity"
+                  }
+                ]
+              }
+            }
+          },
+          "400": {
+            "description": "Bad request - deviceId parameter is missing",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "error": {
+                      "type": "string"
+                    }
+                  }
+                },
+                "example": {
+                  "error": "deviceId is required"
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal server error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "error": {
+                      "type": "string"
+                    }
+                  }
+                },
+                "example": {
+                  "error": "Failed to fetch sensors"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/measurements": {
+      "post": {
+        "tags": [
+          "Public · Measurements"
+        ],
+        "summary": "Create new measurements",
+        "description": "Accepts an array of measurement data and stores it in the database",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/Measurement"
+                },
+                "example": [
+                  {
+                    "sensorId": "sensor-123",
+                    "time": "2023-05-15T10:00:00Z",
+                    "value": 25.4
+                  },
+                  {
+                    "sensorId": "sensor-456",
+                    "time": "2023-05-15T10:01:00Z",
+                    "value": 22.1
+                  }
+                ]
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Measurements successfully stored",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Measurements successfully stored"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Invalid data format",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Invalid data format"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "405": {
+            "description": "Method not allowed",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Method not allowed"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/users/me": {
+      "get": {
+        "tags": [
+          "Public · User Management"
+        ],
+        "summary": "Get current user profile",
+        "description": "Retrieves the authenticated user's profile information",
+        "operationId": "getCurrentUser",
+        "security": [
+          {
+            "bearerAuth": []
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successfully retrieved user profile",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "code": {
+                      "type": "string",
+                      "example": "Ok"
+                    },
+                    "data": {
+                      "type": "object",
+                      "properties": {
+                        "me": {
+                          "$ref": "#/components/schemas/User"
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "403": {
+            "description": "Invalid or missing JWT token",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "code": {
+                      "type": "string",
+                      "example": "Forbidden"
+                    },
+                    "message": {
+                      "type": "string",
+                      "example": "Invalid JWT authorization. Please sign in to obtain new JWT."
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal server error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "error": {
+                      "type": "string",
+                      "example": "Internal Server Error"
+                    },
+                    "message": {
+                      "type": "string",
+                      "example": "The server was unable to complete your request. Please try again later."
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "put": {
+        "tags": [
+          "Public · User Management"
+        ],
+        "summary": "Update user profile",
+        "description": "Updates the authenticated user's profile information",
+        "operationId": "updateUserProfile",
+        "security": [
+          {
+            "bearerAuth": []
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "email": {
+                    "type": "string",
+                    "format": "email",
+                    "description": "New email address",
+                    "example": "newemail@example.com"
+                  },
+                  "language": {
+                    "type": "string",
+                    "description": "Preferred language setting",
+                    "example": "en"
+                  },
+                  "name": {
+                    "type": "string",
+                    "description": "User's display name",
+                    "example": "John Doe"
+                  },
+                  "currentPassword": {
+                    "type": "string",
+                    "format": "password",
+                    "description": "Current password (required for password change)",
+                    "example": "currentPassword123"
+                  },
+                  "newPassword": {
+                    "type": "string",
+                    "format": "password",
+                    "description": "New password",
+                    "example": "newPassword456"
+                  }
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "User profile updated successfully or no changes made",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "oneOf": [
+                    {
+                      "type": "object",
+                      "description": "Profile updated successfully",
+                      "properties": {
+                        "code": {
+                          "type": "string",
+                          "example": "Ok"
+                        },
+                        "message": {
+                          "type": "string",
+                          "example": "User successfully saved. Password updated."
+                        },
+                        "data": {
+                          "type": "object",
+                          "properties": {
+                            "me": {
+                              "$ref": "#/components/schemas/User"
+                            }
+                          }
+                        }
+                      }
+                    },
+                    {
+                      "type": "object",
+                      "description": "No changes made",
+                      "properties": {
+                        "code": {
+                          "type": "string",
+                          "example": "Ok"
+                        },
+                        "message": {
+                          "type": "string",
+                          "example": "No changed properties supplied. User remains unchanged."
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad request - validation errors",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "code": {
+                      "type": "string",
+                      "example": "Bad Request"
+                    },
+                    "message": {
+                      "type": "string",
+                      "example": "Current password is incorrect"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "403": {
+            "description": "Invalid or missing JWT token",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ForbiddenError"
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal server error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InternalServerError"
+                }
+              }
+            }
+          }
+        }
+      },
+      "delete": {
+        "tags": [
+          "Public · User Management"
+        ],
+        "summary": "Delete user account",
+        "description": "Permanently deletes the authenticated user's account",
+        "operationId": "deleteUserAccount",
+        "security": [
+          {
+            "bearerAuth": []
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/x-www-form-urlencoded": {
+              "schema": {
+                "type": "object",
+                "required": [
+                  "password"
+                ],
+                "properties": {
+                  "password": {
+                    "type": "string",
+                    "format": "password",
+                    "description": "Current password for account deletion confirmation",
+                    "example": "myCurrentPassword123"
+                  }
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Account successfully deleted",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "null",
+                  "description": "Empty response indicating successful deletion"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad request - missing password",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "type": "string",
+                  "example": "Bad Request"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "Unauthorized - incorrect password",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Password incorrect"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "403": {
+            "description": "Invalid or missing JWT token",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ForbiddenError"
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal server error",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "type": "string",
+                  "example": "Internal Server Error"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/users/refresh-auth": {
+      "post": {
+        "tags": [
+          "Public · Authentication"
+        ],
+        "summary": "Refresh authentication token",
+        "description": "Refreshes a JWT access token using a valid refresh token",
+        "operationId": "refreshAuth",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "required": [
+                  "token"
+                ],
+                "properties": {
+                  "token": {
+                    "type": "string",
+                    "description": "Valid refresh token",
+                    "example": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+                  }
+                }
+              }
+            },
+            "application/x-www-form-urlencoded": {
+              "schema": {
+                "type": "object",
+                "required": [
+                  "token"
+                ],
+                "properties": {
+                  "token": {
+                    "type": "string",
+                    "description": "Valid refresh token",
+                    "example": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+                  }
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Successfully refreshed authentication",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "code": {
+                      "type": "string",
+                      "example": "Authorized"
+                    },
+                    "message": {
+                      "type": "string",
+                      "example": "Successfully refreshed auth"
+                    },
+                    "data": {
+                      "type": "object",
+                      "properties": {
+                        "user": {
+                          "$ref": "#/components/schemas/User"
+                        }
+                      }
+                    },
+                    "token": {
+                      "type": "string",
+                      "description": "New JWT access token",
+                      "example": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+                    },
+                    "refreshToken": {
+                      "type": "string",
+                      "description": "New JWT refresh token",
+                      "example": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "403": {
+            "description": "Authentication failed - invalid or expired refresh token",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "code": {
+                      "type": "string",
+                      "example": "Forbidden"
+                    },
+                    "message": {
+                      "type": "string",
+                      "enum": [
+                        "You must specify a token to refresh",
+                        "Refresh token invalid or too old. Please sign in with your username and password."
+                      ]
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal server error",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "type": "string",
+                  "example": "Internal Server Error"
+                }
+              }
+            }
           }
+        }
+      }
+    },
+    "/api/users/register": {
+      "post": {
+        "tags": [
+          "Public · Authentication"
         ],
+        "summary": "Register a new user",
+        "description": "Creates a new user account with username, email, password, and language preference",
+        "operationId": "registerUser",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/x-www-form-urlencoded": {
+              "schema": {
+                "type": "object",
+                "required": [
+                  "name",
+                  "email",
+                  "password"
+                ],
+                "properties": {
+                  "name": {
+                    "type": "string",
+                    "description": "Username for the new account",
+                    "minLength": 3,
+                    "maxLength": 40,
+                    "pattern": "^[a-zA-Z0-9][a-zA-Z0-9._\\- ]*$",
+                    "example": "john_doe"
+                  },
+                  "email": {
+                    "type": "string",
+                    "format": "email",
+                    "description": "Email address for the new account",
+                    "example": "john.doe@example.com"
+                  },
+                  "password": {
+                    "type": "string",
+                    "format": "password",
+                    "description": "Password for the new account",
+                    "minLength": 8,
+                    "example": "mySecurePassword123"
+                  },
+                  "language": {
+                    "type": "string",
+                    "description": "Preferred language for the user",
+                    "enum": [
+                      "de_DE",
+                      "en_US"
+                    ],
+                    "default": "en_US",
+                    "example": "en_US"
+                  }
+                }
+              }
+            }
+          }
+        },
         "responses": {
-          "200": {
-            "description": "Successful operation",
+          "201": {
+            "description": "User successfully registered",
             "content": {
               "application/json": {
                 "schema": {
-                  "type": "array",
-                  "items": {
-                    "$ref": "#/components/schemas/Sensor"
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Successfully registered new user"
+                    },
+                    "token": {
+                      "type": "string",
+                      "description": "JWT access token",
+                      "example": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+                    },
+                    "refreshToken": {
+                      "type": "string",
+                      "description": "JWT refresh token",
+                      "example": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+                    },
+                    "data": {
+                      "$ref": "#/components/schemas/User"
+                    }
                   }
                 },
-                "example": [
-                  {
-                    "id": "sensor-1",
-                    "name": "Temperature Sensor",
-                    "type": "temperature"
-                  },
-                  {
-                    "id": "sensor-2",
-                    "name": "Humidity Sensor",
-                    "type": "humidity"
+                "example": {
+                  "message": "Successfully registered new user",
+                  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+                  "refreshToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+                  "data": {
+                    "id": "user_123456",
+                    "username": "john_doe",
+                    "email": "john.doe@example.com",
+                    "language": "en_US"
                   }
-                ]
+                }
               }
             }
           },
           "400": {
-            "description": "Bad request - deviceId parameter is missing",
+            "description": "Bad request - validation error or user already exists",
             "content": {
               "application/json": {
                 "schema": {
                   "type": "object",
                   "properties": {
-                    "error": {
+                    "message": {
                       "type": "string"
                     }
                   }
                 },
-                "example": {
-                  "error": "deviceId is required"
+                "examples": {
+                  "userExists": {
+                    "summary": "User already exists",
+                    "value": {
+                      "message": "User already exists."
+                    }
+                  },
+                  "usernameRequired": {
+                    "summary": "Username validation failed",
+                    "value": {
+                      "message": "Username is required."
+                    }
+                  },
+                  "emailInvalid": {
+                    "summary": "Email validation failed",
+                    "value": {
+                      "message": "Invalid email format."
+                    }
+                  },
+                  "passwordTooShort": {
+                    "summary": "Password validation failed",
+                    "value": {
+                      "message": "Password must be at least 8 characters long."
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "405": {
+            "description": "Method not allowed - only POST requests are accepted",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "type": "string"
                 }
               }
             }
@@ -209,95 +2383,380 @@
                 "schema": {
                   "type": "object",
                   "properties": {
-                    "error": {
+                    "message": {
                       "type": "string"
                     }
                   }
                 },
                 "example": {
-                  "error": "Failed to fetch sensors"
+                  "message": "Unable to create jwt for newly created user: Token generation failed"
                 }
+              },
+              "text/plain": {
+                "schema": {
+                  "type": "string"
+                },
+                "example": "Internal Server Error"
               }
             }
           }
         }
       }
     },
-    "/api/measurements": {
+    "/api/users/sign-in": {
       "post": {
         "tags": [
-          "Measurements"
+          "Public · Authentication"
         ],
-        "summary": "Create new measurements",
-        "description": "Accepts an array of measurement data and stores it in the database",
+        "summary": "User sign-in",
+        "description": "Authenticates a user with email and password credentials",
+        "operationId": "signInUser",
         "requestBody": {
           "required": true,
           "content": {
-            "application/json": {
+            "application/x-www-form-urlencoded": {
               "schema": {
-                "type": "array",
-                "items": {
-                  "$ref": "#/components/schemas/Measurement"
-                },
-                "example": [
-                  {
-                    "sensorId": "sensor-123",
-                    "time": "2023-05-15T10:00:00Z",
-                    "value": 25.4
+                "type": "object",
+                "required": [
+                  "email",
+                  "password"
+                ],
+                "properties": {
+                  "email": {
+                    "type": "string",
+                    "format": "email",
+                    "description": "User's email address",
+                    "example": "user@example.com"
                   },
-                  {
-                    "sensorId": "sensor-456",
-                    "time": "2023-05-15T10:01:00Z",
-                    "value": 22.1
+                  "password": {
+                    "type": "string",
+                    "format": "password",
+                    "description": "User's password",
+                    "minLength": 8,
+                    "example": "mySecurePassword123"
                   }
-                ]
+                }
               }
             }
           }
         },
         "responses": {
           "200": {
-            "description": "Measurements successfully stored",
+            "description": "Successfully authenticated",
             "content": {
               "application/json": {
                 "schema": {
                   "type": "object",
                   "properties": {
+                    "code": {
+                      "type": "string",
+                      "example": "Authorized"
+                    },
                     "message": {
                       "type": "string",
-                      "example": "Measurements successfully stored"
+                      "example": "Successfully signed in"
+                    },
+                    "data": {
+                      "type": "object",
+                      "properties": {
+                        "user": {
+                          "$ref": "#/components/schemas/User"
+                        }
+                      }
+                    },
+                    "token": {
+                      "type": "string",
+                      "description": "JWT access token",
+                      "example": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+                    },
+                    "refreshToken": {
+                      "type": "string",
+                      "description": "JWT refresh token",
+                      "example": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
                     }
                   }
                 }
               }
             }
           },
-          "400": {
-            "description": "Invalid data format",
+          "403": {
+            "description": "Authentication failed - invalid credentials or missing fields",
             "content": {
               "application/json": {
                 "schema": {
                   "type": "object",
                   "properties": {
+                    "code": {
+                      "type": "string",
+                      "example": "Forbidden"
+                    },
                     "message": {
                       "type": "string",
-                      "example": "Invalid data format"
+                      "enum": [
+                        "You must specify either your email or your username",
+                        "You must specify your password to sign in",
+                        "User and or password not valid!"
+                      ]
                     }
                   }
                 }
               }
             }
           },
-          "405": {
-            "description": "Method not allowed",
+          "500": {
+            "description": "Internal server error",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "type": "string",
+                  "example": "Internal Server Error"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/integrations/{deviceId}": {
+      "get": {
+        "summary": "Get integration configuration for a device",
+        "operationId": "getIntegration",
+        "tags": [
+          "Integration · Integration Management"
+        ],
+        "parameters": [
+          {
+            "$ref": "#/components/parameters/DeviceId"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Integration configuration",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/IntegrationConfig"
+                }
+              }
+            }
+          },
+          "401": {
+            "$ref": "#/components/responses/Unauthorized"
+          },
+          "404": {
+            "$ref": "#/components/responses/NotFound"
+          },
+          "500": {
+            "$ref": "#/components/responses/InternalError"
+          }
+        }
+      },
+      "put": {
+        "summary": "Create or update integration configuration",
+        "operationId": "createOrUpdateIntegration",
+        "tags": [
+          "Integration · Integration Management"
+        ],
+        "parameters": [
+          {
+            "$ref": "#/components/parameters/DeviceId"
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "description": "Configuration specific to your integration type",
+                "additionalProperties": true
+              },
+              "examples": {
+                "mqtt": {
+                  "summary": "MQTT Integration",
+                  "value": {
+                    "url": "mqtt://broker.example.com:1883",
+                    "topic": "sensors/temperature",
+                    "messageFormat": "json",
+                    "connectionOptions": {
+                      "username": "user",
+                      "password": "pass"
+                    }
+                  }
+                },
+                "ttn": {
+                  "summary": "TTN Integration",
+                  "value": {
+                    "devId": "my-device",
+                    "appId": "my-app",
+                    "profile": "cayenne-lpp"
+                  }
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Integration updated",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/IntegrationConfig"
+                }
+              }
+            }
+          },
+          "201": {
+            "description": "Integration created",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/IntegrationConfig"
+                }
+              }
+            }
+          },
+          "400": {
+            "$ref": "#/components/responses/ValidationError"
+          },
+          "401": {
+            "$ref": "#/components/responses/Unauthorized"
+          },
+          "500": {
+            "$ref": "#/components/responses/InternalError"
+          }
+        }
+      },
+      "delete": {
+        "summary": "Delete integration configuration",
+        "operationId": "deleteIntegration",
+        "tags": [
+          "Integration · Integration Management"
+        ],
+        "parameters": [
+          {
+            "$ref": "#/components/parameters/DeviceId"
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "Integration deleted successfully"
+          },
+          "401": {
+            "$ref": "#/components/responses/Unauthorized"
+          },
+          "404": {
+            "$ref": "#/components/responses/NotFound"
+          },
+          "500": {
+            "$ref": "#/components/responses/InternalError"
+          }
+        }
+      }
+    },
+    "/integrations/schema/{integrationName}": {
+      "get": {
+        "summary": "Get JSON Schema for integration configuration form",
+        "operationId": "getIntegrationSchema",
+        "tags": [
+          "Integration · Schema"
+        ],
+        "parameters": [
+          {
+            "name": "integrationName",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "example": "mqtt"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "JSON Schema for dynamic form generation",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/JsonSchema"
+                },
+                "examples": {
+                  "mqtt": {
+                    "summary": "MQTT Schema Example",
+                    "value": {
+                      "schema": {
+                        "type": "object",
+                        "required": [
+                          "url",
+                          "topic",
+                          "messageFormat"
+                        ],
+                        "properties": {
+                          "url": {
+                            "type": "string",
+                            "title": "Broker URL",
+                            "pattern": "^(mqtt|mqtts|ws|wss)://.+"
+                          },
+                          "topic": {
+                            "type": "string",
+                            "title": "Topic"
+                          },
+                          "messageFormat": {
+                            "type": "string",
+                            "title": "Message Format",
+                            "enum": [
+                              "json",
+                              "csv"
+                            ]
+                          }
+                        }
+                      },
+                      "uiSchema": {
+                        "ui:order": [
+                          "url",
+                          "topic",
+                          "messageFormat"
+                        ]
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "401": {
+            "$ref": "#/components/responses/Unauthorized"
+          },
+          "500": {
+            "$ref": "#/components/responses/InternalError"
+          }
+        }
+      }
+    },
+    "/health": {
+      "get": {
+        "summary": "Health check endpoint",
+        "operationId": "healthCheck",
+        "tags": [
+          "Integration · Health"
+        ],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "Service is healthy",
             "content": {
               "application/json": {
                 "schema": {
                   "type": "object",
                   "properties": {
-                    "message": {
+                    "status": {
                       "type": "string",
-                      "example": "Method not allowed"
+                      "example": "healthy"
+                    },
+                    "timestamp": {
+                      "type": "string",
+                      "format": "date-time"
                     }
                   }
                 }
@@ -308,5 +2767,37 @@
       }
     }
   },
-  "tags": []
+  "tags": [
+    {
+      "name": "Integration · Integration Management",
+      "description": "CRUD operations for integration configurations"
+    },
+    {
+      "name": "Integration · Schema",
+      "description": "JSON Schema for dynamic form generation"
+    },
+    {
+      "name": "Integration · Health",
+      "description": "Service health check"
+    }
+  ],
+  "security": [
+    {
+      "ServiceKey": []
+    }
+  ],
+  "x-tagGroups": [
+    {
+      "name": "Public API",
+      "tags": []
+    },
+    {
+      "name": "Integration API",
+      "tags": [
+        "Integration · Integration Management",
+        "Integration · Schema",
+        "Integration · Health"
+      ]
+    }
+  ]
 }
\ No newline at end of file
diff --git a/scripts/generate-openapi.ts b/scripts/generate-openapi.ts
index 3786e4a4..64765ad6 100644
--- a/scripts/generate-openapi.ts
+++ b/scripts/generate-openapi.ts
@@ -1,10 +1,9 @@
-// scripts/generate-openapi.ts
-import { writeFileSync } from 'node:fs'
-import { openapiSpecification } from '../app/lib/openapi.js'
+import { writeFileSync } from "node:fs";
+import { combinedOpenapiSpecification } from "../app/lib/openapi.combined.js";
 
 writeFileSync(
-	'./public/openapi.json',
-	JSON.stringify(openapiSpecification(), null, 2),
-)
+  "./public/openapi.json",
+  JSON.stringify(combinedOpenapiSpecification(), null, 2),
+);
 
-console.info('✅ OpenAPI spec generated')
+console.info("✅ OpenAPI spec generated");
\ No newline at end of file