.Net C# Json deserialize concrete implementations of abstract class error

Question

I would like to store a list of transactions in a list as a json. (Register transaction, unregister transaction etc). Each transaction has an upload method, and the implementation of the upload method is specific to the transaction type (calls a different endpoint on a server).

For this I created an abstract class called "TransactionTypeBase", that contains an upload method that will be overriden and triggered when deserializing and enumerating the list of concrete transactions types.

The issue is when deserializng the List<TransactionTypeBase> I get this error:

Deserialization of reference types without parameterless constructor is not supported. Type MyProject.TransactionTypeBase' (also nto sure if the serialization is done properly in this case)

I do understand from research that I have to create a custom converter inheriting from JsonConverter but I am not sure how to actually implement that for my case, and that is where I need help please.

This is my code:

public abstract class TransactionTypeBase
    {
        public abstract TransactionType TransactionType { get; }

        public abstract Task UploadToServer(Data data);
    }

    public enum TransactionType
    {
        Register = 1,
        Unregister = 2
    }

public class RegisterTransactionType : TransactionTypeBase
    {
        public override TransactionType TransactionType => TransactionType.Register;

        public override async Task UploadToServer(Data data)
        {
            // Call Register API endpoint
        }
    }

public class UnregisterTransactionType : TransactionTypeBase
    {
        public override TransactionType TransactionType => TransactionType.Unregister;

        public override async Task UploadToServer(Data data)
        {
            // call Unregister API endpoint
        }
    }


    public class Transactions : List<TransactionTypeBase>
    {

        public void Add(TransactionTypeBase type)
        {
            if (type is RegisterTransactionType)
            {
                // do some optional additional work
            }

            base.Add(type);
        }
    }


   public class Data
   {
      public int Id {get;set;}
      public string Username {get;set;}
      ..........................
   }

In usage:

......

var transactions = new Transactions();

if (isRegister)
   transactions.Add(new RegisterTransactionType());
else
   transactions.Add(new UnregisterTransactionType());

.......

To store transactions in a json format:

var serializedTransactionList = JsonSerializer.Serialize<Transactions>();

To later deserialize and enumerate (and where error occurs):

var deserializedTransactionList = JsonDeserialize<Transactions>(serializedTransactionList);

The purpose was to achieve this point, to trigger the saved transactions later on, when there is internet connection of for whatever other reason:

foreach (var transaction in deserializedTransactionList)
 {
   transaction.Upload(data); // where the endpoint is called based on what type of transaction it is.
 }