diff --git a/backend/src/Designer/Exceptions/Options/InvalidOptionsFormatException.cs b/backend/src/Designer/Exceptions/Options/InvalidOptionsFormatException.cs
new file mode 100644
index 00000000000..0dc69bc495d
--- /dev/null
+++ b/backend/src/Designer/Exceptions/Options/InvalidOptionsFormatException.cs
@@ -0,0 +1,25 @@
+using System;
+
+namespace Altinn.Studio.Designer.Exceptions.Options;
+
+/// <summary>
+/// Indicates that an error occurred during json serialization of options.
+/// </summary>
+[Serializable]
+public class InvalidOptionsFormatException : Exception
+{
+    /// <inheritdoc/>
+    public InvalidOptionsFormatException()
+    {
+    }
+
+    /// <inheritdoc/>
+    public InvalidOptionsFormatException(string message) : base(message)
+    {
+    }
+
+    /// <inheritdoc/>
+    public InvalidOptionsFormatException(string message, Exception innerException) : base(message, innerException)
+    {
+    }
+}
diff --git a/backend/src/Designer/Filters/Options/OptionsErrorCodes.cs b/backend/src/Designer/Filters/Options/OptionsErrorCodes.cs
new file mode 100644
index 00000000000..9053087b1b5
--- /dev/null
+++ b/backend/src/Designer/Filters/Options/OptionsErrorCodes.cs
@@ -0,0 +1,6 @@
+namespace Altinn.Studio.Designer.Filters.Options;
+
+public class OptionsErrorCodes
+{
+    public const string InvalidOptionsFormat = nameof(InvalidOptionsFormat);
+}
diff --git a/backend/src/Designer/Filters/Options/OptionsExceptionFilterAttribute.cs b/backend/src/Designer/Filters/Options/OptionsExceptionFilterAttribute.cs
new file mode 100644
index 00000000000..ead5e0a589a
--- /dev/null
+++ b/backend/src/Designer/Filters/Options/OptionsExceptionFilterAttribute.cs
@@ -0,0 +1,26 @@
+using System.Net;
+using Altinn.Studio.Designer.Exceptions.Options;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Controllers;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace Altinn.Studio.Designer.Filters.Options;
+
+public class OptionsExceptionFilterAttribute : ExceptionFilterAttribute
+{
+    public override void OnException(ExceptionContext context)
+    {
+        base.OnException(context);
+
+        if (context.ActionDescriptor is not ControllerActionDescriptor)
+        {
+            return;
+        }
+
+        if (context.Exception is InvalidOptionsFormatException)
+        {
+            context.Result = new ObjectResult(ProblemDetailsUtils.GenerateProblemDetails(context.Exception, OptionsErrorCodes.InvalidOptionsFormat, HttpStatusCode.BadRequest)) { StatusCode = (int)HttpStatusCode.BadRequest };
+        }
+    }
+
+}
diff --git a/backend/src/Designer/Filters/ProblemDetailsExtensionsCodes.cs b/backend/src/Designer/Filters/ProblemDetailsExtensionsCodes.cs
index 4064393c200..a70c0f6f152 100644
--- a/backend/src/Designer/Filters/ProblemDetailsExtensionsCodes.cs
+++ b/backend/src/Designer/Filters/ProblemDetailsExtensionsCodes.cs
@@ -3,5 +3,5 @@ namespace Altinn.Studio.Designer.Filters;
 public static class ProblemDetailsExtensionsCodes
 {
     public const string ErrorCode = "errorCode";
-
+    public const string Detail = "detail";
 }
diff --git a/backend/src/Designer/Helpers/JsonConverterHelpers/NotNullableAttribute.cs b/backend/src/Designer/Helpers/JsonConverterHelpers/NotNullableAttribute.cs
new file mode 100644
index 00000000000..c4a556f977c
--- /dev/null
+++ b/backend/src/Designer/Helpers/JsonConverterHelpers/NotNullableAttribute.cs
@@ -0,0 +1,15 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Altinn.Studio.Designer.Helpers.JsonConverterHelpers;
+
+public class NotNullableAttribute : ValidationAttribute
+{
+    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
+    {
+        if (value == null)
+        {
+            return new ValidationResult("The field is required.");
+        }
+        return ValidationResult.Success;
+    }
+}
diff --git a/backend/src/Designer/Helpers/JsonConverterHelpers/OptionConverterHelper.cs b/backend/src/Designer/Helpers/JsonConverterHelpers/OptionConverterHelper.cs
index a15ad94deeb..9ba74b172ef 100644
--- a/backend/src/Designer/Helpers/JsonConverterHelpers/OptionConverterHelper.cs
+++ b/backend/src/Designer/Helpers/JsonConverterHelpers/OptionConverterHelper.cs
@@ -1,10 +1,11 @@
 using System;
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using Altinn.Studio.Designer.Exceptions.Options;
 
 namespace Altinn.Studio.Designer.Helpers.JsonConverterHelpers;
 
-public class OptionConverter : JsonConverter<object>
+public class OptionValueConverter : JsonConverter<object>
 {
     public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
     {
@@ -14,7 +15,7 @@ public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonS
             JsonTokenType.Number when reader.TryGetDouble(out double d) => d,
             JsonTokenType.True => true,
             JsonTokenType.False => false,
-            _ => throw new JsonException($"Unsupported JSON token for Option.Value: {reader.TokenType}")
+            _ => throw new InvalidOptionsFormatException($"Unsupported JSON token for Value field, {typeToConvert}: {reader.TokenType}.")
         };
     }
 
@@ -32,7 +33,7 @@ public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOp
                 writer.WriteBooleanValue(b);
                 break;
             default:
-                throw new JsonException("Unsupported type for Option.Value.");
+                throw new InvalidOptionsFormatException($"{value} is an unsupported type for Value field. Accepted types are string, double and bool.");
         }
     }
 }
diff --git a/backend/src/Designer/Infrastructure/MvcConfiguration.cs b/backend/src/Designer/Infrastructure/MvcConfiguration.cs
index b135b5a35cc..990b05a5498 100644
--- a/backend/src/Designer/Infrastructure/MvcConfiguration.cs
+++ b/backend/src/Designer/Infrastructure/MvcConfiguration.cs
@@ -2,6 +2,7 @@
 using Altinn.Studio.Designer.Filters.DataModeling;
 using Altinn.Studio.Designer.Filters.Git;
 using Altinn.Studio.Designer.Filters.IO;
+using Altinn.Studio.Designer.Filters.Options;
 using Altinn.Studio.Designer.ModelBinding;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.DependencyInjection;
@@ -26,6 +27,7 @@ public static IServiceCollection ConfigureMvc(this IServiceCollection services)
                     options.Filters.Add(typeof(DataModelingExceptionFilterAttribute));
                     options.Filters.Add(typeof(GitExceptionFilterAttribute));
                     options.Filters.Add(typeof(IoExceptionFilterAttribute));
+                    options.Filters.Add(typeof(OptionsExceptionFilterAttribute));
                 })
                 .AddNewtonsoftJson(options => options.SerializerSettings.Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter()));
 
diff --git a/backend/src/Designer/Models/Option.cs b/backend/src/Designer/Models/Option.cs
index ddfa6b9559e..b49a499ad28 100644
--- a/backend/src/Designer/Models/Option.cs
+++ b/backend/src/Designer/Models/Option.cs
@@ -1,4 +1,3 @@
-using System.ComponentModel.DataAnnotations;
 using System.Text.Json.Serialization;
 using Altinn.Studio.Designer.Helpers.JsonConverterHelpers;
 
@@ -12,17 +11,17 @@ public class Option
     /// <summary>
     /// Value that connects the option to the data model.
     /// </summary>
-    [Required]
+    [NotNullable]
     [JsonPropertyName("value")]
-    [JsonConverter(typeof(OptionConverter))]
-    public object Value { get; set; }
+    [JsonConverter(typeof(OptionValueConverter))]
+    public required object Value { get; set; }
 
     /// <summary>
     /// Label to present to the user.
     /// </summary>
-    [Required]
+    [NotNullable]
     [JsonPropertyName("label")]
-    public string Label { get; set; }
+    public required string Label { get; set; }
 
     /// <summary>
     /// Description, typically displayed below the label.
diff --git a/backend/src/Designer/Services/Implementation/OptionsService.cs b/backend/src/Designer/Services/Implementation/OptionsService.cs
index f1834c3156a..137b0cf5c34 100644
--- a/backend/src/Designer/Services/Implementation/OptionsService.cs
+++ b/backend/src/Designer/Services/Implementation/OptionsService.cs
@@ -1,8 +1,9 @@
 using System.Collections.Generic;
-using System.Linq;
+using System.ComponentModel.DataAnnotations;
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
+using Altinn.Studio.Designer.Exceptions.Options;
 using Altinn.Studio.Designer.Models;
 using Altinn.Studio.Designer.Services.Interfaces;
 using LibGit2Sharp;
@@ -50,9 +51,26 @@ public async Task<List<Option>> GetOptionsList(string org, string repo, string d
 
         string optionsListString = await altinnAppGitRepository.GetOptionsList(optionsListId, cancellationToken);
         var optionsList = JsonSerializer.Deserialize<List<Option>>(optionsListString);
+
+        try
+        {
+            optionsList.ForEach(ValidateOption);
+        }
+        catch (ValidationException)
+        {
+            throw new InvalidOptionsFormatException($"One or more of the options have an invalid format in option list: {optionsListId}.");
+        }
+
+
         return optionsList;
     }
 
+    private void ValidateOption(Option option)
+    {
+        var validationContext = new ValidationContext(option);
+        Validator.ValidateObject(option, validationContext, validateAllProperties: true);
+    }
+
     /// <inheritdoc />
     public async Task<List<Option>> CreateOrOverwriteOptionsList(string org, string repo, string developer, string optionsListId, List<Option> payload, CancellationToken cancellationToken = default)
     {
@@ -73,10 +91,10 @@ public async Task<List<Option>> UploadNewOption(string org, string repo, string
         List<Option> deserializedOptions = JsonSerializer.Deserialize<List<Option>>(payload.OpenReadStream(),
             new JsonSerializerOptions { WriteIndented = true, AllowTrailingCommas = true });
 
-        IEnumerable<Option> result = deserializedOptions.Where(option => IsNullOrEmptyOptionValue(option) || string.IsNullOrEmpty(option.Label));
-        if (result.Any())
+        bool optionListHasInvalidNullFields = deserializedOptions.Exists(option => option.Value == null || option.Label == null);
+        if (optionListHasInvalidNullFields)
         {
-            throw new JsonException("Uploaded file is missing one of the following attributes for an option: value or label.");
+            throw new InvalidOptionsFormatException("Uploaded file is missing one of the following attributes for an option: value or label.");
         }
 
         var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
@@ -85,16 +103,6 @@ public async Task<List<Option>> UploadNewOption(string org, string repo, string
         return deserializedOptions;
     }
 
-    bool IsNullOrEmptyOptionValue(object value)
-    {
-        if (value == null)
-        {
-            return true;
-        }
-
-        return value is string stringOption && string.IsNullOrEmpty(stringOption);
-    }
-
     /// <inheritdoc />
     public void DeleteOptionsList(string org, string repo, string developer, string optionsListId)
     {
diff --git a/backend/tests/Designer.Tests/Controllers/AppDevelopmentController/GetOptionListIdsTests.cs b/backend/tests/Designer.Tests/Controllers/AppDevelopmentController/GetOptionListIdsTests.cs
index b501fd527fb..c5b77263ef4 100644
--- a/backend/tests/Designer.Tests/Controllers/AppDevelopmentController/GetOptionListIdsTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/AppDevelopmentController/GetOptionListIdsTests.cs
@@ -29,6 +29,7 @@ public async Task GetOptionsListIds_ShouldReturnOk(string org, string app, strin
             {
                 { "other-options" },
                 { "test-options" },
+                { "options-with-null-fields" },
             };
 
             string url = $"{VersionPrefix(org, targetRepository)}/option-list-ids";
@@ -39,7 +40,7 @@ public async Task GetOptionsListIds_ShouldReturnOk(string org, string app, strin
 
             string responseContent = await response.Content.ReadAsStringAsync();
             List<string> responseList = JsonSerializer.Deserialize<List<string>>(responseContent);
-            responseList.Count.Should().Be(2);
+            responseList.Count.Should().Be(3);
             foreach (string id in expectedOptionsListIds)
             {
                 responseList.Should().Contain(id);
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs
index 6406ed2f63f..fc3c00fbc0a 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs
@@ -1,11 +1,13 @@
 using System.Collections.Generic;
-using System.Linq;
 using System.Net.Http;
 using System.Text.Json;
 using System.Threading.Tasks;
+using Altinn.Studio.Designer.Filters;
 using Altinn.Studio.Designer.Models;
 using Designer.Tests.Controllers.ApiTests;
+using FluentAssertions;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Testing;
 using Xunit;
 
@@ -96,4 +98,26 @@ public async Task GetSingleOptionsList_Returns404NotFound_WhenOptionsListDoesNot
         // Assert
         Assert.Equal(StatusCodes.Status404NotFound, (int)response.StatusCode);
     }
+
+    [Fact]
+    public async Task GetSingleOptionsList_Returns400BadRequest_WhenOptionsListIsInvalid()
+    {
+        // Arrange
+        const string repo = "app-with-options";
+        const string optionsListId = "options-with-null-fields";
+
+        string apiUrl = $"/designer/api/ttd/{repo}/options/{optionsListId}";
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode);
+
+        var problemDetails = JsonSerializer.Deserialize<ProblemDetails>(await response.Content.ReadAsStringAsync());
+        problemDetails.Should().NotBeNull();
+        JsonElement errorCode = (JsonElement)problemDetails.Extensions[ProblemDetailsExtensionsCodes.ErrorCode];
+        errorCode.ToString().Should().Be("InvalidOptionsFormat");
+    }
 }
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/UpdateOptionsTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/UpdateOptionsTests.cs
index 94e11ef07a4..28a3fbad16b 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/UpdateOptionsTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/UpdateOptionsTests.cs
@@ -1,12 +1,15 @@
 using System.Collections.Generic;
 using System.Net.Http;
-using System.Net.Http.Json;
+using System.Text;
 using System.Text.Json;
 using System.Threading.Tasks;
+using Altinn.Studio.Designer.Filters;
 using Altinn.Studio.Designer.Models;
 using Designer.Tests.Controllers.ApiTests;
 using Designer.Tests.Utils;
+using FluentAssertions;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Testing;
 using Xunit;
 
@@ -31,23 +34,15 @@ public async Task Put_Returns_200OK_When_Creating_New_OptionsList()
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
 
-        var newOptionsList = new List<Option>
-        {
-            new ()
-            {
-                Label = "label1",
-                Value = "value1",
-            },
-            new ()
-            {
-                Label = "label2",
-                Value = "value2",
-            }
-        };
+        string optionsJson = @"[
+            { ""label"": ""label1"", ""value"": ""value1"" },
+            { ""label"": ""label2"", ""value"": ""value2"" }
+        ]";
+        List<Option> expectedOptionList = JsonSerializer.Deserialize<List<Option>>(optionsJson);
 
         string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionsListId}";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
-        httpRequestMessage.Content = JsonContent.Create(newOptionsList);
+        httpRequestMessage.Content = new StringContent(optionsJson, Encoding.UTF8, "application/json");
 
         // Act
         using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
@@ -56,14 +51,14 @@ public async Task Put_Returns_200OK_When_Creating_New_OptionsList()
 
         // Assert
         Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
-        Assert.Equal(newOptionsList.Count, responseList.Count);
+        Assert.Equal(expectedOptionList.Count, responseList.Count);
 
-        for (int i = 0; i < newOptionsList.Count; i++)
+        for (int i = 0; i < responseList.Count; i++)
         {
-            Assert.Equal(newOptionsList[i].Label, responseList[i].Label);
-            Assert.Equal(newOptionsList[i].Value, responseList[i].Value);
-            Assert.Equal(newOptionsList[i].Description, responseList[i].Description);
-            Assert.Equal(newOptionsList[i].HelpText, responseList[i].HelpText);
+            Assert.Equal(expectedOptionList[i].Label, responseList[i].Label);
+            Assert.Equal(expectedOptionList[i].Value, responseList[i].Value);
+            Assert.Equal(expectedOptionList[i].Description, responseList[i].Description);
+            Assert.Equal(expectedOptionList[i].HelpText, responseList[i].HelpText);
         }
     }
 
@@ -79,25 +74,36 @@ public async Task Put_Returns_200OK_When_Option_Values_Are_Bool_String_Double()
         string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionsListId}";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
 
-        var stringBoolDoubleOptionsList = new List<Option>
-        {
-            new ()
-            {
-                Label = "StringValue",
-                Value = "value1",
-            },
-            new ()
-            {
-                Label = "BoolValue",
-                Value = true,
-            },
-            new ()
-            {
-                Label = "DoubleValue",
-                Value = 3.1415,
-            }
-        };
-        httpRequestMessage.Content = JsonContent.Create(stringBoolDoubleOptionsList);
+        var stringBoolDoubleOptionsList = @"[
+            { ""label"": ""StringValue"", ""value"": ""value"" },
+            { ""label"": ""BoolValue"", ""value"": true },
+            { ""label"": ""NumberValue"", ""value"": 3.1415 },
+        ]";
+        httpRequestMessage.Content = new StringContent(stringBoolDoubleOptionsList, Encoding.UTF8, "application/json");
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
+    }
+
+    [Fact]
+    public async Task Put_Returns_200OK_When_Option_Value_And_Label_Are_Empty_Strings()
+    {
+        string repo = "app-with-options";
+        string optionsListId = "test-options";
+        // Arrange
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionsListId}";
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
+
+        var emptyStringsValueAndLabelOptionsList = @"[
+            { ""label"": """", ""value"": """" },
+        ]";
+        httpRequestMessage.Content = new StringContent(emptyStringsValueAndLabelOptionsList, Encoding.UTF8, "application/json");
 
         // Act
         using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
@@ -116,23 +122,15 @@ public async Task Put_Returns_200OK_And_Overwrites_Existing_OptionsList()
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
 
-        var newOptionsList = new List<Option>
-        {
-            new ()
-            {
-                Label = "aNewLabelThatDidNotExistBefore",
-                Value = "aNewValueThatDidNotExistBefore",
-            },
-            new ()
-            {
-                Label = "label2",
-                Value = "value2",
-            }
-        };
+        var newOptionsList = @"[
+            { ""label"": ""aNewLabelThatDidNotExistBefore"", ""value"": ""aNewValueThatDidNotExistBefore"" },
+            { ""label"": ""label2"", ""value"": ""value2"" }
+        ]";
+        List<Option> expectedOptionList = JsonSerializer.Deserialize<List<Option>>(newOptionsList);
 
         string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionsListId}";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
-        httpRequestMessage.Content = JsonContent.Create(newOptionsList);
+        httpRequestMessage.Content = new StringContent(newOptionsList, Encoding.UTF8, "application/json");
 
         // Act
         using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
@@ -141,84 +139,106 @@ public async Task Put_Returns_200OK_And_Overwrites_Existing_OptionsList()
 
         // Assert
         Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
-        Assert.Equal(newOptionsList.Count, responseList.Count);
+        Assert.Equal(expectedOptionList.Count, responseList.Count);
 
-        for (int i = 0; i < newOptionsList.Count; i++)
+        for (int i = 0; i < expectedOptionList.Count; i++)
         {
-            Assert.Equal(newOptionsList[i].Label, responseList[i].Label);
-            Assert.Equal(newOptionsList[i].Value, responseList[i].Value);
-            Assert.Equal(newOptionsList[i].Description, responseList[i].Description);
-            Assert.Equal(newOptionsList[i].HelpText, responseList[i].HelpText);
+            Assert.Equal(expectedOptionList[i].Label, responseList[i].Label);
+            Assert.Equal(expectedOptionList[i].Value, responseList[i].Value);
+            Assert.Equal(expectedOptionList[i].Description, responseList[i].Description);
+            Assert.Equal(expectedOptionList[i].HelpText, responseList[i].HelpText);
         }
     }
 
-    [Theory]
-    [InlineData("options-missing-label")]
-    [InlineData("options-empty-json")]
-    public async Task Put_Returns_400BadRequest_When_OptionsList_Format_Is_Invalid(string optionsListId)
+    [Fact]
+    public async Task Put_Returns_400BadRequest_When_Options_Is_Empty()
     {
         // Arrange
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await CopyRepositoryForTest(Org, "empty-app", Developer, targetRepository);
 
-        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionsListId}";
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/empty-options";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
 
-        if (optionsListId == "options-missing-label")
-        {
-            var invalidOptionsList = new List<Option>
-            {
-                new ()
-                {
-                    // Missing Label
-                    Value = "value1",
-                },
-                new ()
-                {
-                    Label = "label2",
-                    Value = "value2",
-                }
-            };
-            httpRequestMessage.Content = JsonContent.Create(invalidOptionsList);
-        }
-        else if (optionsListId == "options-empty-json")
-        {
-            httpRequestMessage.Content = JsonContent.Create<List<Option>>(null);
-        }
+
+        httpRequestMessage.Content = new StringContent("null", Encoding.UTF8, "application/json");
 
         // Act
         using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        var responseContent = await response.Content.ReadAsStringAsync();
+        var responseObject = JsonSerializer.Deserialize<JsonElement>(responseContent);
 
         // Assert
         Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode);
+        Assert.True(responseObject.TryGetProperty("errors", out JsonElement errors));
+        Assert.True(errors.TryGetProperty("", out JsonElement labelErrors));
+        Assert.Contains("A non-empty request body is required.", labelErrors[0].GetString());
     }
 
     [Fact]
     public async Task Put_Returns_400BadRequest_When_Option_Value_Is_Invalid()
     {
-        string repo = "app-with-options";
-        string optionsListId = "test-options";
         // Arrange
         string targetRepository = TestDataHelper.GenerateTestRepoName();
-        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+        await CopyRepositoryForTest(Org, "empty-app", Developer, targetRepository);
 
-        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionsListId}";
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/option-invalid-value";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
 
-        var invalidOptionsList = new List<Option>
-        {
-            new ()
-            {
-                Label = "ObjectValue",
-                Value = { },
-            },
-        };
-        httpRequestMessage.Content = JsonContent.Create(invalidOptionsList);
+        string optionsInvalidValue = @"[
+            { ""value"": {}, ""label"": ""label2"" },
+        ]";
+
+        httpRequestMessage.Content = new StringContent(optionsInvalidValue, Encoding.UTF8, "application/json");
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        var problemDetails = JsonSerializer.Deserialize<ProblemDetails>(await response.Content.ReadAsStringAsync());
+
+        // Assert
+        Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode);
+
+        problemDetails.Should().NotBeNull();
+        JsonElement errorCode = (JsonElement)problemDetails.Extensions[ProblemDetailsExtensionsCodes.ErrorCode];
+        errorCode.ToString().Should().Be("InvalidOptionsFormat");
+    }
+
+    [Fact]
+    public async Task Put_Returns_400BadRequest_When_Options_Has_Missing_Required_Fields()
+    {
+        // Arrange
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(Org, "empty-app", Developer, targetRepository);
+
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/options-missing-fields";
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
+
+        string optionsWithMissingFields = @"[
+            { ""value"": ""value1"" },
+            { ""label"": ""label2"" },
+            { ""value"": null, ""label"": null },
+        ]";
+        httpRequestMessage.Content = new StringContent(optionsWithMissingFields, Encoding.UTF8, "application/json");
 
         // Act
         using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        var responseContent = await response.Content.ReadAsStringAsync();
+        var responseObject = JsonSerializer.Deserialize<JsonElement>(responseContent);
 
         // Assert
         Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode);
+        Assert.True(responseObject.TryGetProperty("errors", out JsonElement errors));
+
+        Assert.True(errors.TryGetProperty("[0].Label", out JsonElement labelErrors));
+        Assert.Contains("The field is required.", labelErrors[0].GetString());
+
+        Assert.True(errors.TryGetProperty("[1].Value", out JsonElement valueErrors));
+        Assert.Contains("The field is required.", valueErrors[0].GetString());
+
+        Assert.True(errors.TryGetProperty("[2].Value", out JsonElement valueNullErrors));
+        Assert.Contains("The field is required.", valueNullErrors[0].GetString());
+        Assert.True(errors.TryGetProperty("[2].Label", out JsonElement labelNullErrors));
+        Assert.Contains("The field is required.", labelNullErrors[0].GetString());
     }
 }
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/UploadOptionsTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/UploadOptionsTests.cs
new file mode 100644
index 00000000000..709ed0befde
--- /dev/null
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/UploadOptionsTests.cs
@@ -0,0 +1,196 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Filters;
+using Altinn.Studio.Designer.Models;
+using Designer.Tests.Controllers.ApiTests;
+using Designer.Tests.Utils;
+using FluentAssertions;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Xunit;
+
+namespace Designer.Tests.Controllers.OptionsController;
+
+public class UploadOptionsTests : DesignerEndpointsTestsBase<UploadOptionsTests>, IClassFixture<WebApplicationFactory<Program>>
+{
+    public UploadOptionsTests(WebApplicationFactory<Program> factory) : base(factory)
+    {
+    }
+
+    private const string VersionPrefix = "designer/api";
+    private const string Org = "ttd";
+    private const string Developer = "testUser";
+
+    [Fact]
+    public async Task Post_Returns_200OK_When_Uploading_New_OptionsList()
+    {
+        // Arrange
+        const string repo = "empty-app";
+
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        string optionsFileName = "options.json";
+        string jsonOptions = @"[
+        {""label"": ""Label1"", ""value"": ""Value1"", ""description"": ""Description1"", ""helpText"": ""helpText"" },
+        {""label"": ""Label2"", ""value"": ""Value2"" }
+    ]";
+
+        byte[] optionsBytes = Encoding.UTF8.GetBytes(jsonOptions);
+        string apiUrl = $"{VersionPrefix}/{Org}/{targetRepository}/options/upload";
+        var content = new MultipartFormDataContent();
+        var optionsContent = new ByteArrayContent(optionsBytes);
+        optionsContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
+        content.Add(optionsContent, "file", optionsFileName);
+        using HttpRequestMessage httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, apiUrl)
+        {
+            Content = content
+        };
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        var responseList = JsonSerializer.Deserialize<List<Option>>(responseBody);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
+        Assert.Equal(2, responseList.Count);
+    }
+
+    [Fact]
+    public async Task Post_Returns_200OK_When_Uploading_New_OptionsList_With_Empty_Strings()
+    {
+        // Arrange
+        const string repo = "empty-app";
+
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        string optionsFileName = "simple-options.json";
+        string jsonOptions = @"[
+        {""label"": """", ""value"": """" },
+    ]";
+
+        byte[] optionsBytes = Encoding.UTF8.GetBytes(jsonOptions);
+        string apiUrl = $"{VersionPrefix}/{Org}/{targetRepository}/options/upload";
+        var content = new MultipartFormDataContent();
+        var optionsContent = new ByteArrayContent(optionsBytes);
+        optionsContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
+        content.Add(optionsContent, "file", optionsFileName);
+        using HttpRequestMessage httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, apiUrl)
+        {
+            Content = content
+        };
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
+    }
+
+    [Fact]
+    public async Task Post_Returns_400BadRequest_When_Uploading_New_OptionsList_With_Missing_Fields()
+    {
+        // Arrange
+        const string repo = "empty-app";
+
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        string optionsFileName = "missing-fields-options.json";
+        string jsonOptions = @"[
+        {""value"": """" }, 
+        {""label"": """" },
+    ]";
+
+        byte[] optionsBytes = Encoding.UTF8.GetBytes(jsonOptions);
+        string apiUrl = $"{VersionPrefix}/{Org}/{targetRepository}/options/upload";
+        var content = new MultipartFormDataContent();
+        var optionsContent = new ByteArrayContent(optionsBytes);
+        optionsContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
+        content.Add(optionsContent, "file", optionsFileName);
+        using HttpRequestMessage httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, apiUrl)
+        {
+            Content = content
+        };
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode);
+    }
+
+    [Fact]
+    public async Task Post_Returns_400BadRequest_When_Uploading_New_OptionsList_With_Null_Values()
+    {
+        // Arrange
+        const string repo = "empty-app";
+
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        string optionsFileName = "null-options.json";
+        string jsonOptions = @"[
+        {""label"": null, ""value"": null }
+    ]";
+
+        byte[] optionsBytes = Encoding.UTF8.GetBytes(jsonOptions);
+        string apiUrl = $"{VersionPrefix}/{Org}/{targetRepository}/options/upload";
+        var content = new MultipartFormDataContent();
+        var optionsContent = new ByteArrayContent(optionsBytes);
+        optionsContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
+        content.Add(optionsContent, "file", optionsFileName);
+        using HttpRequestMessage httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, apiUrl)
+        {
+            Content = content
+        };
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode);
+    }
+
+    [Fact]
+    public async Task Post_Returns_400BadRequest_When_Uploading_New_OptionsList_With_Invalid_Format()
+    {
+        // Arrange
+        const string repo = "empty-app";
+
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        string optionsFileName = "invalid-value-options.json";
+        string jsonOptions = @"[{""value"": {}, ""label"": """"}]";
+
+        byte[] optionsBytes = Encoding.UTF8.GetBytes(jsonOptions);
+        string apiUrl = $"{VersionPrefix}/{Org}/{targetRepository}/options/upload";
+        var content = new MultipartFormDataContent();
+        var optionsContent = new ByteArrayContent(optionsBytes);
+        optionsContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
+        content.Add(optionsContent, "file", optionsFileName);
+        using HttpRequestMessage httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, apiUrl)
+        {
+            Content = content
+        };
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode);
+
+        var problemDetails = JsonSerializer.Deserialize<ProblemDetails>(await response.Content.ReadAsStringAsync());
+        problemDetails.Should().NotBeNull();
+        JsonElement errorCode = (JsonElement)problemDetails.Extensions[ProblemDetailsExtensionsCodes.ErrorCode];
+        errorCode.ToString().Should().Be("InvalidOptionsFormat");
+    }
+}
diff --git a/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnAppGitRepositoryTests.cs b/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnAppGitRepositoryTests.cs
index a8fdab0af65..ad920f48a16 100644
--- a/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnAppGitRepositoryTests.cs
+++ b/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnAppGitRepositoryTests.cs
@@ -291,7 +291,7 @@ public Task GetOptionListIds_WithAppThatHasOptionLists_ShouldReturnOptionListPat
             string[] optionListIds = altinnAppGitRepository.GetOptionsListIds();
 
             optionListIds.Should().NotBeNull();
-            optionListIds.Should().HaveCount(2);
+            optionListIds.Should().HaveCount(3);
             return Task.CompletedTask;
         }
 
diff --git a/backend/tests/Designer.Tests/Services/OptionsServiceTests.cs b/backend/tests/Designer.Tests/Services/OptionsServiceTests.cs
index 2a7322f1488..3d787539035 100644
--- a/backend/tests/Designer.Tests/Services/OptionsServiceTests.cs
+++ b/backend/tests/Designer.Tests/Services/OptionsServiceTests.cs
@@ -18,7 +18,7 @@ public class OptionsServiceTests
     public async Task GetOptionsListIds_ShouldReturnOptionsListIds_WhenOptionsListsExist()
     {
         // Arrange
-        const string repo = "app-with-options"; // Has 2 options lists
+        const string repo = "app-with-options";
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
 
@@ -27,14 +27,14 @@ public async Task GetOptionsListIds_ShouldReturnOptionsListIds_WhenOptionsListsE
         string[] optionListIds = optionsService.GetOptionsListIds(Org, targetRepository, Developer);
 
         // Assert
-        Assert.Equal(2, optionListIds.Length);
+        Assert.Equal(3, optionListIds.Length);
     }
 
     [Fact]
     public async Task GetOptionsListIds_ShouldReturnEmptyArray_WhenOptionsListsDoesNotExist()
     {
         // Arrange
-        const string repo = "empty-app"; // Has no options lists
+        const string repo = "empty-app";
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
 
@@ -50,7 +50,6 @@ public async Task GetOptionsListIds_ShouldReturnEmptyArray_WhenOptionsListsDoesN
     public async Task GetOptionsList_ShouldReturnOptionsList_WhenOptionsExists()
     {
         // Arrange
-        // This  options list matches the options in 'app-with-options'
         var expectedOptions = new List<Option>
         {
             new Option
@@ -90,7 +89,7 @@ public async Task GetOptionsList_ShouldReturnOptionsList_WhenOptionsExists()
     public async Task GetOptionsList_ShouldThrowNotFoundException_WhenOptionsListDoesNotExist()
     {
         // Arrange
-        const string repo = "empty-app"; // Has no options lists
+        const string repo = "empty-app";
         const string optionListId = "test-options";
 
         var optionsService = GetOptionsServiceForTest();
@@ -120,7 +119,7 @@ public async Task CreateOrOverwriteOptionsList_ShouldReturnUpdatedOptionsList_Wh
             }
         };
 
-        const string repo = "empty-app"; // Has no options lists
+        const string repo = "empty-app";
         const string optionListId = "test-options";
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
@@ -160,13 +159,13 @@ public async Task CreateOrOverwriteOptionsList_ShouldReturnUpdatedOptionsList_Wh
         };
 
         const string repo = "app-with-options";
-        const string optionListId = "test-options"; // Name of an existing options list
+        const string existingOptionListId = "test-options";
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
 
         // Act
         var optionsService = GetOptionsServiceForTest();
-        var updatedOptions = await optionsService.CreateOrOverwriteOptionsList(Org, targetRepository, Developer, optionListId, newOptions);
+        var updatedOptions = await optionsService.CreateOrOverwriteOptionsList(Org, targetRepository, Developer, existingOptionListId, newOptions);
 
         // Assert
         Assert.Equal(updatedOptions.Count, updatedOptions.Count);
diff --git a/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/app-with-options/App/options/options-with-null-fields.json b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/app-with-options/App/options/options-with-null-fields.json
new file mode 100644
index 00000000000..49b3aec5409
--- /dev/null
+++ b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/app-with-options/App/options/options-with-null-fields.json
@@ -0,0 +1,6 @@
+[
+{
+  "label": null,
+  "value": null
+}
+]
\ No newline at end of file
diff --git a/frontend/language/src/nb.json b/frontend/language/src/nb.json
index 36ff8751b4f..c497a216ae4 100644
--- a/frontend/language/src/nb.json
+++ b/frontend/language/src/nb.json
@@ -7,6 +7,7 @@
   "api_errors.DM_CsharpCompiler_NameCollision": "Navnet <bold>{{nodeName}}</bold> er det samme som på et overordnet element. Gi ett av elementene et annet navn.",
   "api_errors.GT_01": "Det er en konflikt i appen",
   "api_errors.GT_03": "Du blir logget ut fordi økten din har utløpt. Logg inn på nytt.",
+  "api_errors.InvalidOptionsFormat": "Kodelisten har ugyldig format.",
   "api_errors.ModelWithTheSameTypeNameExists": "Det er allerede et skjema som produserer modellen med navnet du har oppgitt",
   "api_errors.ResourceNotFound": "Fant ikke en fil som appen din prøvde å få tak i.",
   "api_errors.Unauthorized": "Handlingen du prøver å utføre krever rettigheter du ikke har. Du blir nå logget ut.",