How to serialize list of enum using their string value

You could use the StringEnumConverter provided by Json.Net rather than defining a custom converter, along with using the EnumMemberAttribute instead of JsonPropertyAttribute.

For Example,

[JsonConverter(typeof(StringEnumConverter))]
public enum AccessScope
{
    [EnumMember(Value="read_content")]
    ReadContent,

    [EnumMember(Value="write_content")]
    WriteContent,

    [EnumMember(Value="read_themes")]
    ReadThemes,

    [EnumMember(Value="write_themes")]
    WriteThemes
} 

Now you can deserialize as

var requiredPermissions = new List<AccessScope>()
{
    AccessScope.ReadContent,
    AccessScope.WriteContent,
};

var result = JsonConvert.SerializeObject(requiredPermissions);

Output

["read_content","write_content"]

You need a custom converter; perhaps:

using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Reflection;

static class P
{
    class ByNameStringEnumConverter : StringEnumConverter
    {
        static ConcurrentDictionary<Type, (string name, object value)[]> s_byTypeCache = new ConcurrentDictionary<Type, (string name, object value)[]>();

        static (string name, object value)[] GetMap(Type type) => s_byTypeCache.TryGetValue(type, out var result) ? result : AddForType(type);
        static (string name, object value)[] AddForType(Type type)
        {
            var fields = type.GetFields(BindingFlags.Static | BindingFlags.Public);
            var map = Array.ConvertAll(fields, field =>
            {
                string name = field.Name;
                if (Attribute.GetCustomAttribute(field, typeof(JsonPropertyAttribute)) is JsonPropertyAttribute jprop
                    && !string.IsNullOrWhiteSpace(jprop.PropertyName))
                {
                    name = jprop.PropertyName;
                }
                return (name, field.GetValue(null));
            });
            s_byTypeCache.TryAdd(type, map);
            return map;
        }
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.String && reader.Value is string s && objectType.IsEnum)
            {
                var map = GetMap(objectType);
                for (int i = 0; i < map.Length; i++)
                    if (map[i].name == s) return map[i].value;
            }
            return base.ReadJson(reader, objectType, existingValue, serializer);
        }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            Type type = value?.GetType();
            if (type is object && type.IsEnum)
            {
                var map = GetMap(type);
                for (int i = 0; i < map.Length; i++)
                {
                    if (Equals(map[i].value, value))
                    {
                        writer.WriteValue(map[i].name);
                        return;
                    }
                }
            }
            base.WriteJson(writer, value, serializer);
        }
    }
    [JsonConverter(typeof(ByNameStringEnumConverter))]
    public enum AccessScope
    {
        [JsonProperty("read_content")]
        ReadContent,

        [JsonProperty("write_content")]
        WriteContent,

        [JsonProperty("read_themes")]
        ReadThemes,

        [JsonProperty("write_themes")]
        WriteThemes
    }
    static void Main()
    {
        var requiredPermissions = new List<AccessScope>()
        {
            AccessScope.ReadContent,
            AccessScope.WriteContent,
        };

        var json = JsonConvert.SerializeObject(requiredPermissions);

        Console.WriteLine(json);

        // and back again
        var obj = JsonConvert.DeserializeObject<List<AccessScope>>(json);
        foreach(var val in obj)
            Console.WriteLine(val);
    }
}