public class IntervalMeta
    {
        public long? Timestamp { get; set; }
		[JsonExtensionData]
        public Dictionary<string, JsonElement>? MeasurementPoints { get; set; } = new();
    }

public Dictionary<string, SubInterval[]>? MeasurementPoints { get; set; } = new();

public class SubInterval
    {
		public string? Max { get; set; }
        public string? Label { get; set; }
    }

public class MeasurementPointDictionaryJsonConverter : JsonConverter<Dictionary<string, SubInterval>>
    {
        public override Dictionary<string, SubInterval[]>? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            var dict = new Dictionary<string, SubInterval[]>();
			// Issue 3: How do loop over the contents in the Interval node (containing 0 or more SubIntervals)
            while (reader.Read())
            {
                // Issue 1: How do I read the key?
                var measurementPointId = reader.GetString();
                // Issue 2: How do I deserialize the node to a SubInterval?
                string value = reader.GetString();
                var intervals = JsonSerializer.Deserialize<SubInterval[]>(value, options);
                
                dict.Add(measurementPointId ?? "", intervals ?? new());
            }
            return dict;
        }
        public override void Write(Utf8JsonWriter writer, Dictionary<string, SubInterval[]> value, JsonSerializerOptions options)
        {
            throw new NotImplementedException();
        }
    }

[JsonConverter(typeof(MeasurementPointDictionaryJsonConverter))]
public Dictionary<string, SubInterval[]>? MeasurementPoints { get; set; } = new();

[JsonExtensionData]
[JsonConverter(typeof(MeasurementPointDictionaryJsonConverter))]
public Dictionary<string, SubInterval[]>? MeasurementPoints { get; set; } = new();

 public class CustomConverter : JsonConverter<List<IntervalMeta>>
    {
        public override List<IntervalMeta> Read(ref Utf8JsonReader reader, Type typeToConvert,
            JsonSerializerOptions options)
        {
            using var jsonDocument = JsonDocument.ParseValue(ref reader);
            var root = jsonDocument.RootElement;
            var intervals = root.GetProperty("intervals").EnumerateArray();
            var values = new List<IntervalMeta>();
            foreach (var interval in intervals)
            {
                var item = new IntervalMeta();
                    
                foreach (var property in interval.EnumerateObject())
                {
                    if (property.Name == "timestamp")
                    {
                        if (property.Value.TryGetInt64(out var value))
                        {
                            item.Timestamp = value;
                        }
                    }
                    else
                    {
                        var key = property.Name;
                        var enumerateObject = property.Value.EnumerateObject();
                        if (!enumerateObject.Any()) continue;
                        var subIntervalArray = enumerateObject.First();
                        var subIntervalsJson = subIntervalArray.Value.GetRawText();
                        var subIntervals = JsonSerializer.Deserialize<SubInterval[]>(subIntervalsJson,
                            new JsonSerializerOptions()
                            {
                                PropertyNameCaseInsensitive = true
                            });
                        item.MeasurementPoints.Add(key, subIntervals);
                    }
                }
                values.Add(item);
            }
            return values;
        }
        public override void Write(Utf8JsonWriter writer, List<IntervalMeta> value, JsonSerializerOptions options)
        {
            throw new NotImplementedException();
        }
    }

public class IntervalMeta
{
    public long? Timestamp { get; set; }
    public Dictionary<string, SubInterval[]> MeasurementPoints { get; set; } = new();
}
public class SubInterval
{
    public string Max { get; set; }
    public string Label { get; set; }
}
class Program
{
    static async Task Main(string[] args)
    {
        var input = @"
        {
           ""intervals"":[
              {
                 ""timestamp"":1677477728,
                 ""123456"":{
                    ""subintervals"":[
                       {
                          ""max"":""56.7"",
                          ""label"":""Leq""
                       },
                       {
                          ""max"":""58.1"",
                          ""label"":""Lmax""
                       }
                    ]
                 }
              },
              {
                 ""timestamp"":1677477730,
                 ""54321"":{
                    ""subintervals"":[
                       {
                          ""value"":""58.5"",
                          ""label"":""Leq""
                       },
                       {
                          ""value"":""59.5"",
                          ""label"":""Lmax""
                       }
                    ]
                 },
                 ""56789"":{
                    ""subintervals"":[
                       {
                          ""value"":""78.2"",
                          ""label"":""Lmax""
                       },
                       {
                          ""value"":""74.3"",
                          ""label"":""Leq""
                       }
                    ]
                 }
              }
           ]
        }";
        var test = JsonSerializer.Deserialize<List<IntervalMeta>>(input, new JsonSerializerOptions
        {
            Converters = { new CustomConverter() },
            PropertyNameCaseInsensitive = true
        });
    }

var list = JsonConvert.DeserializeObject<List<IntervalMeta>>(input, new CustomConverter());
public class CustomConverter : CustomCreationConverter<List<IntervalMeta>>
{
    public override List<IntervalMeta> Create(Type objectType)
    {
        return new List<IntervalMeta>();
    }
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
    {
        JObject jObject = JObject.Load(reader);
        IList<JToken> intervals = jObject["intervals"].Children().ToList();
        return intervals.Select(jToken =>
        {
            var item = new IntervalMeta();
            foreach (var jProperty in jToken.OfType<JProperty>())
            {
                if (jProperty.Name == "timestamp")
                {
                    if (long.TryParse(jProperty.Value.ToString(), out var value))
                    {
                        item.Timestamp = value;
                    }
                    continue;
                }
                var key = jProperty.Name;
                var jPropertyValue = jProperty.Value.First.First;
                var subinternvalDictionary = jPropertyValue.ToObject<SubInterval[]>();
                item.MeasurementPoints.Add(key, subinternvalDictionary);
            }
            return item;
        }).ToList();
    }
}

using Newtonsoft.Json
List<Interval> intervals=JsonConvert.DeserializeObject<List<Interval>>(json,new DictToListConverter());
public class DictToListConverter : JsonConverter
{
	public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
	{
		throw new NotImplementedException();
	}
	public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
	{
		var jObj = JObject.Load(reader);
		
		return  jObj["intervals"].Select(x => GetInterval((JObject)x)).ToList();
                               
	}
	public override bool CanConvert(Type objectType)
	{
		return true;
	}
	public  Interval GetInterval(JObject jObj)
	{
		var interval = jObj.ToObject<IntervalTemp>();
		interval.subintervals = new List<SubintervalItem>();
		foreach (var item in interval.dict)
		{
			var sii = new SubintervalItem { name = item.Key, subintervals = new List<Subinterval>() };
			sii.subintervals = item.Value["subintervals"].Select(d => d.ToObject<Subinterval>()).ToList();
			interval.subintervals.Add(sii);
		}
		return JObject.FromObject(interval).ToObject<Interval>();
        //or if a performance is an issue
		//interval.dict = null;
		//return interval;
	}
}

public class IntervalTemp : Interval
{
	[JsonExtensionData]
	public Dictionary<string, JToken> dict { get; set; }
	
}
public class Interval
{
	public long timestamp { get; set; }
	public List<SubintervalItem> subintervals { get; set; }
}
public class SubintervalItem
{
	public string name { get; set; }
	public List<Subinterval> subintervals { get; set; }
}
public class Subinterval
{
	public string max { get; set; }
	public string label { get; set; }
	public string value { get; set; }
}