Finally, this is my proof of concept v1:

    [HttpGet]
    public HttpResponseMessage GetCustomer(Guid guid)
    {
        var logData = new ExtendedLoggerData();
        logData.AddCategory("Merchello");
        logData.AddCategory("AjourCMSApi");

        var getCustomerResponse = GetCustomer(guid, logData);

        var response = new HttpResponseMessage
        {
            Content = new ObjectContent<GetCustomerResponse>(getCustomerResponse, Configuration.Formatters.JsonFormatter),
            StatusCode = HttpStatusCode.OK
        };
        return response;
    }

    private GetCustomerResponse GetCustomer(Guid guid, ExtendedLoggerData loggerData)
    {
        var getCustomerResponse = new GetCustomerResponse();

        var merchelloServices = MerchelloContext.Current.Services;
        var customerService = merchelloServices.CustomerService;
        var customer = customerService.GetByKey(guid);

        if (customer == null)
        {
            throw new Exception("Customer does not exists", null);
        }

        getCustomerResponse.Customer = customer;
        getCustomerResponse.CustomerFound = true;

        var umbracoServices = ApplicationContext.Current.Services;
        var memberService = umbracoServices.MemberService;

        var member = memberService.GetByEmail(customer.Email);
        if (member == null)
        {
            throw new Exception("Member does not exists", null);
        }

        getCustomerResponse.Member = member;
        getCustomerResponse.MemberFound = true;

        return getCustomerResponse;
    }


    internal class GetCustomerResponse
    {
        public ICustomer Customer = null;
        public bool CustomerFound = false;
        public IMember Member = null;
        public bool MemberFound = false;
    }



    /// <summary>
    /// Gets the <see cref="NewMemberModelFactory{TModel}"/>.
    /// </summary>
    private NewMemberModelFactory<NewMemberModel> NewMemberModelFactory { get; set; }

    [HttpGet]
    public HttpResponseMessage CreateCustomer(string loginName, string firstName, string lastName, string email, string password, string addressName = null, string addressAddress1 = null,
        string addressAddress2 = null, string addressOrganization = null, string addressLocality = null, string addressRegion = null, string addressPhone = null, string addressPostalCode = null,
        string addressCountryCode = null)
    {
        var logData = new ExtendedLoggerData();
        logData.AddCategory("Merchello");
        logData.AddCategory("AjourCMSApi");

        var createdCustomer = new CreateCustomerResponse();

        Mandate.ParameterNotNullOrEmpty(loginName, "loginName");
        Mandate.ParameterNotNullOrEmpty(firstName, "firstName");
        Mandate.ParameterNotNullOrEmpty(lastName, "lastName");
        Mandate.ParameterNotNullOrEmpty(email, "email");
        Mandate.ParameterNotNullOrEmpty(password, "password");

        var merchelloServices = MerchelloContext.Current.Services;
        var customerService = merchelloServices.CustomerService;
        var existingCustomer = customerService.GetByLoginName(loginName);
        if (existingCustomer != null)
        {
            throw new Exception("Customer already exists",
                new Exception("Customer already exists: " + existingCustomer.ToStringInternal()));
        }
        var customer = customerService.CreateCustomerWithKey(loginName, firstName, lastName, email);
        var address1 = new Address
        {
            Name = addressName,
            Address1 = addressAddress1,
            Address2 = addressAddress2,
            AddressType = AddressType.Billing,
            Organization = addressOrganization,
            Locality = addressLocality,
            Region = addressRegion,
            Phone = addressPhone,
            PostalCode = addressPostalCode,
            CountryCode = addressCountryCode
        };
        var address2 = new Address
        {
            Name = addressName,
            Address1 = addressAddress1,
            Address2 = addressAddress2,
            AddressType = AddressType.Shipping,
            Organization = addressOrganization,
            Locality = addressLocality,
            Region = addressRegion,
            Phone = addressPhone,
            PostalCode = addressPostalCode,
            CountryCode = addressCountryCode
        };
        customer.CreateCustomerAddress(address1, "defaultBilling", address1.AddressType);
        customer.CreateCustomerAddress(address2, "defaultShipping", address2.AddressType);
        customerService.Save(customer);

        createdCustomer.Customer = customer;
        createdCustomer.CustomerCreated = true;




        var newMemberModelFactory = new NewMemberModelFactory<NewMemberModel>();
        Mandate.ParameterNotNull(newMemberModelFactory, "newMemberModelFactory");
        NewMemberModelFactory = newMemberModelFactory;

        var umbracoServices = ApplicationContext.Current.Services;
        var memberService = umbracoServices.MemberService;

        var model = new NewMemberModel
        {
            FirstName = firstName,
            LastName = lastName,
            Email = email,
            Password = password,
            MemberTypeAlias = "merchelloCustomer",
            ViewData = new StoreViewData(),
            PersistLogin = false
        };

        var registerModel = Members.CreateRegistrationModel(model.MemberTypeAlias);
        registerModel.Name = model.Email;
        registerModel.Email = model.Email;
        registerModel.Password = model.Password;
        registerModel.Username = model.Email;
        registerModel.UsernameIsEmail = true;

        var fn = new UmbracoProperty { Alias = "firstName", Name = "First Name", Value = model.FirstName };
        var ln = new UmbracoProperty { Alias = "lastName", Name = "Last Name", Value = model.LastName };
        registerModel.MemberProperties.Add(fn);
        registerModel.MemberProperties.Add(ln);

        MembershipCreateStatus status;

        //// Add a message for the attempt
        MultiLogHelper.Info<CreateCustomerResponse>("Registering a new member", logData);

        var member = Members.RegisterMember(registerModel, out status, model.PersistLogin);


        var registration = NewMemberModelFactory.Create(model, status);

        if (registration.ViewData.Success)
        {
            var membership = memberService.GetByEmail(model.Email);

            if (member != null)
            {
                memberService.AssignRole(membership.Id, "Customers");
                memberService.Save(membership);
                createdCustomer.Member = membership;
                createdCustomer.MemberCreated = true;
            }

        }

        var response = new HttpResponseMessage
        {
            Content = new ObjectContent<CreateCustomerResponse>(createdCustomer, Configuration.Formatters.JsonFormatter),
            StatusCode = HttpStatusCode.Created
        };
        return response;
    }

    private class CreateCustomerResponse
    {
        public ICustomer Customer = null;
        public bool CustomerCreated = false;
        public IMember Member = null;
        public bool MemberCreated = false;
    }


    [HttpGet]
    public HttpResponseMessage Buy(Guid productKey, Guid customerKey)
    {
        var logData = new ExtendedLoggerData();
        logData.AddCategory("Merchello");
        logData.AddCategory("AjourCMSApi");

        var buyResponse = new BuyResponse();

        Mandate.ParameterNotNullOrEmpty(productKey.ToString(), "productKey");
        Mandate.ParameterNotNullOrEmpty(customerKey.ToString(), "customerKey");

        var merchelloServices = MerchelloContext.Current.Services;

        var customerResponse = GetCustomer(customerKey, logData);
        buyResponse.CustomerResponse = customerResponse;
        var customer = customerResponse.Customer;

        if (customer.Addresses.All(x => x.AddressType != AddressType.Billing))
        {
            var invalidOp = new InvalidOperationException("Billing address not found");
            MultiLogHelper.Error<BuyResponse>("Could not find billing address", invalidOp, logData);
            throw invalidOp;
        }

        var productService = merchelloServices.ProductService;
        var product = productService.GetByKey(productKey);
        if (product == null)
        {
            throw new Exception("Product does not exists", null);
        }

        buyResponse.Product = product;
        buyResponse.ProductFound = true;

        var defaultCatalogKey = MerchelloConstants.Warehouse.DefaultWarehouseCatalogKey;

        var extendedData = new ExtendedDataCollection();
        // this is used to determine where a shipment originates
        extendedData.SetValue(MerchelloConstants.ExtendedDataKeys.WarehouseCatalogKey, defaultCatalogKey.ToString());
        // items set to shippable
        extendedData.SetValue(MerchelloConstants.ExtendedDataKeys.TrackInventory, "false");
        extendedData.SetValue(MerchelloConstants.ExtendedDataKeys.Shippable, "true");
        extendedData.SetValue(MerchelloConstants.ExtendedDataKeys.CurrencyCode, "USD");

        var customerBasket = customer.Basket();
        customerBasket.Empty();
        customerBasket.AddItem(product, product.Name, 1, extendedData);
        customerBasket.Save();

        buyResponse.Basket = customerBasket;
        buyResponse.BasketCreated = true;

        var checkoutMgr = customerBasket.GetCheckoutManager();
        var checkoutCustomer = (ICustomer)checkoutMgr.Customer.Context.Customer;

        var customerExtendedDataRefreshed = RefreshCustomerExtendedData(ref checkoutCustomer);

        buyResponse.CheckoutCustomer = checkoutCustomer;
        buyResponse.CheckoutCustomerFound = true;

        var checkoutCustomerExtendedDataShippingAddress = checkoutCustomer.ExtendedData.GetAddress(AddressType.Shipping);
        var customerCountryCode = checkoutCustomerExtendedDataShippingAddress.CountryCode;

        if (!checkoutMgr.Payment.IsReadyToInvoice())
        {
            var invalidOp = new InvalidOperationException("CheckoutManager is not ready to invoice");
            MultiLogHelper.Error<BuyResponse>("Not ready to invoice", invalidOp, logData);
            throw invalidOp;
        }

        var paymentGatewayMethod = checkoutMgr.Payment.GetPaymentGatewayMethods().FirstOrDefault();

        if (paymentGatewayMethod == null)
        {
            var invalidOp = new InvalidOperationException("Payment Gateway method not found");
            MultiLogHelper.Error<BuyResponse>("Could not find payment gateway method", invalidOp, logData);
            throw invalidOp;
        }

        if (paymentGatewayMethod.PaymentMethod == null)
        {
            var invalidOp = new InvalidOperationException("Payment method not found");
            MultiLogHelper.Error<BuyResponse>("Could not find payment method", invalidOp, logData);
            throw invalidOp;
        }

        buyResponse.PaymentMethod = paymentGatewayMethod.PaymentMethod;
        buyResponse.PaymentMethodSet = true;

        checkoutMgr.Payment.SavePaymentMethod(paymentGatewayMethod.PaymentMethod);

        var authorizePaymentResult = checkoutMgr.Payment.AuthorizePayment(paymentGatewayMethod.PaymentMethod.Key);

        var invoice = authorizePaymentResult.Invoice;

        var invoiceService = merchelloServices.InvoiceService;

        ((Invoice)invoice).CustomerKey = customer.Key;

        invoice.VersionKey = Guid.NewGuid();

        //Preparing shipment
        var gatewayproviderService = merchelloServices.GatewayProviderService;
        var shipmentService = merchelloServices.ShipmentService;
        var catalog = merchelloServices.WarehouseService.GetAllWarehouseCatalogs().FirstOrDefault();
        var shipCountry = gatewayproviderService.GetShipCountry(catalog.Key, customerCountryCode);
        var warehouse = merchelloServices.WarehouseService.GetDefaultWarehouse();
        var shipmentStatus = merchelloServices.ShipmentService.GetShipmentStatusByKey(MerchelloConstants.ShipmentStatus.Quoted);
        var shipment = merchelloServices.ShipmentService.CreateShipment(shipmentStatus, warehouse.AsAddress(), checkoutCustomerExtendedDataShippingAddress, invoice.Items);

        //Get rates and quotes
        var key = MerchelloConstants.ProviderKeys.Shipping.FixedRateShippingProviderKey;

        var rateTableProvider = (FixedRateShippingGatewayProvider)MerchelloContext.Current.Gateways.Shipping.GetProviderByKey(key);
        var shipMethods = rateTableProvider.ShipMethods.ToArray();
        var shipMethod = rateTableProvider.ShipMethods.FirstOrDefault(x => x.ShipCountryKey == shipCountry.Key);
        shipment.ShipMethodKey = shipMethod.Key;

        buyResponse.Shipment = shipment;
        var quote = rateTableProvider.QuoteShipMethodForShipment(shipment, rateTableProvider.GetShippingGatewayMethod(shipMethod.Key, shipCountry.Key));

        //Add shipping quotes to invoice
        var quoteItem = quote.AsLineItemOf<InvoiceLineItem>();
        quoteItem.ExtendedData.AddShipment(shipment);
        invoice.Items.Add(quoteItem);

        invoiceService.Save(invoice);

        buyResponse.Invoice = invoice;
        buyResponse.InvoiceCreated = true;


        var payment = gatewayproviderService.CreatePayment(PaymentMethodType.Cash, invoice.Total, paymentGatewayMethod.PaymentMethod.Key);
        buyResponse.Payment = payment;
        var capturePaymentResult = ((Invoice) invoice).CapturePayment(payment, paymentGatewayMethod, payment.Amount);
        buyResponse.PaymentResult = capturePaymentResult;

        if (capturePaymentResult.Payment.Success)
        {
            var approved = capturePaymentResult.ApproveOrderCreation;
            if (approved)
            {
                var order = ((Invoice) invoice).PrepareOrder();
                order.VersionKey = Guid.NewGuid();
                var orderService = merchelloServices.OrderService;
                orderService.Save(order);
                buyResponse.Order = order;
                buyResponse.OrderCreated = true;

                foreach (var shipment1Item in shipment.Items)
                {
                    shipment1Item.ContainerKey = order.Key;
                }
                shipment.VersionKey = Guid.NewGuid();
                shipmentService.Save(shipment);
                shipment.AuditCreated();

                foreach (var orderShippingItem in order.Items)
                {
                    ((OrderLineItem)orderShippingItem).ShipmentKey = shipment.Key;
                }
                order.VersionKey = Guid.NewGuid();
                orderService.Save(order);
                order.AuditCreated();

                var shipmentStatusFinal = merchelloServices.ShipmentService.GetShipmentStatusByKey(MerchelloConstants.ShipmentStatus.Delivered);
                shipment.ShipmentStatus = shipmentStatusFinal;
                shipment.VersionKey = Guid.NewGuid();
                shipmentService.Save(shipment);
                shipment.AuditStatusChanged();
                buyResponse.ShipmentDelivered = true;

                var orderStatusKey = MerchelloConstants.OrderStatus.Fulfilled;
                var orderStatus = orderService.GetOrderStatusByKey(orderStatusKey);
                order.OrderStatus = orderStatus;
                order.VersionKey = Guid.NewGuid();
                orderService.Save(order);
                buyResponse.OrderFulfilled = true;

            }
        }

        var response = new HttpResponseMessage
        {
            Content = new ObjectContent<BuyResponse>(buyResponse, Configuration.Formatters.JsonFormatter),
            StatusCode = HttpStatusCode.OK
        };
        return response;
    }

    private static bool RefreshCustomerExtendedData(ref ICustomer customer)
    {
        var customerExtendedDataAddressRefreshed = false;
        var customerExtendedDataBillingAddressRefreshed = false;
        var customerExtendedDataShippingAddressRefreshed = false;
        if (customer.Addresses.Any(x => x.AddressType == AddressType.Billing) && customer.ExtendedData.GetAddress(AddressType.Billing) == null)
        {
            var customerBillingAddress = customer.Addresses.First(x => x.AddressType == AddressType.Billing);
            var address1 = new Address
            {
                Name = customerBillingAddress.Label,
                Address1 = customerBillingAddress.Address1,
                Address2 = customerBillingAddress.Address2,
                AddressType = AddressType.Billing,
                Organization = customerBillingAddress.Company,
                Locality = customerBillingAddress.Locality,
                Region = customerBillingAddress.Region,
                Phone = customerBillingAddress.Phone,
                PostalCode = customerBillingAddress.PostalCode,
                CountryCode = customerBillingAddress.CountryCode
            };
            customer.ExtendedData.AddAddress(address1, AddressType.Billing);
            customerExtendedDataBillingAddressRefreshed = true;
        }
        if (customer.Addresses.Any(x => x.AddressType == AddressType.Shipping) && customer.ExtendedData.GetAddress(AddressType.Shipping) == null)
        {
            var customerShippingAddress = customer.Addresses.First(x => x.AddressType == AddressType.Shipping);
            var address2 = new Address
            {
                Name = customerShippingAddress.Label,
                Address1 = customerShippingAddress.Address1,
                Address2 = customerShippingAddress.Address2,
                AddressType = AddressType.Shipping,
                Organization = customerShippingAddress.Company,
                Locality = customerShippingAddress.Locality,
                Region = customerShippingAddress.Region,
                Phone = customerShippingAddress.Phone,
                PostalCode = customerShippingAddress.PostalCode,
                CountryCode = customerShippingAddress.CountryCode
            };
            customer.ExtendedData.AddAddress(address2, AddressType.Shipping);
            customerExtendedDataShippingAddressRefreshed = true;
        }
        customerExtendedDataAddressRefreshed = customerExtendedDataBillingAddressRefreshed || customerExtendedDataShippingAddressRefreshed;

        return customerExtendedDataAddressRefreshed;
    }

    internal class BuyResponse
    {
        public GetCustomerResponse CustomerResponse = null;
        public ICustomer CheckoutCustomer = null;
        public bool CheckoutCustomerFound = false;
        public IProduct Product = null;
        public bool ProductFound = false;
        public IBasket Basket = null;
        public bool BasketCreated = false;
        public IPaymentMethod PaymentMethod = null;
        public bool PaymentMethodSet = false;
        public IInvoice Invoice = null;
        public bool InvoiceCreated = false;
        public IPayment Payment = null;
        public IPaymentResult PaymentResult = null;
        public IOrder Order = null;
        public bool OrderCreated = false;
        public IShipment Shipment = null;
        public bool ShipmentDelivered = false;
        public bool OrderFulfilled = false;
    }

It creates a new customer and buys a product on behalf of the customer. This will be useful in the scenario where the customer wants to buy a digital product from the merchello webshop without the web interface. One aspect I intended here is that the chain of operation could be continued by the customer manually using the web interface of merchello, at any stage. Rusty, if you have some time, could you please point me to anything I'm doing wrong here ?