I was recently working with a React developer on a data driven single page application using an ASP.NET WebAPI backend. I wanted the API to be RESTful to simplify the design, since React can provide client side state and in fact is driven by application state and the API was only there to provide data and persistence. We decided to use the HATEOAS convention, of simply adding a "links" section to each of the objects, in order to inform the client of the available associated resource URIs. Based loosely on the HAL standards we agreed that we simply wanted to add some basic links within the normal JSON response as opposed to negotiating new media types etc. For this very basic requirement then, comes a very simple solution. I created a base class in my API Models folder which would support links:
public class LinkModel
{
    public LinkModel()
    {
    }

    public LinkModel(string href, string method, string rel)
        : this()
    {
        this.Href = href;
        this.Method = method;
        this.Rel = rel;
    }

    public string Method { get; set; }
    public string Rel { get; set; }
    public string Href { get; set; }
}
And then a generic class which would contain the payload object, or "content" and the "links":
public class ContentWithLinks<T>
{
    public ContentWithLinks()
    {
    }

    public ContentWithLinks(T content, IEnumerable<LinkModel> links)
        : this()
    {
        this.Content = content;
        this.Links = links;
    }

    public T Content { get; set; }
    public IEnumerable<LinkModel> Links { get; set; }
}
Each of my actions that wanted to use this strategy would return this type with the calculated links:
[HttpGet]
[Route]
public IEnumerable<ContentWithLinks<DataSetModel>> GetAllDataSets()
{
    return new ContentWithLinks<DataSetModel>[]
    {
        new ContentWithLinks<DataSetModel>(new DataSetModel("Example"), this.GetLinks("Example"))
    };
}

private IEnumerable<LinkModel> GetLinks(string dataSetName)
{
    return new LinkModel[]
    {
        new LinkModel(this.Url.Link(nameof(this.GetAnalysisSchemaForDataSet), new { dataSetName = dataSetName }), "GET", "Schema"),
        new LinkModel(this.Url.Link(nameof(FiltersController.GetAllFilters), new { dataSetName = dataSetName }), "GET", "Filters"),
        new LinkModel(this.Url.Link(nameof(FilesController.GetAllFiles), new { dataSetName = dataSetName }), "GET", "Files")
    };
}
Using the "Url.Link" syntax ensure the route is calculated by ASP.NET. In fact, I went ahead and used the "nameof" operator too, to ensure any code refactorings of these methods would be taken in account automatically. In the client side the various links were then bound to the different actions a user could perform, which would trigger a call to the next URI in the workflow, generating more links and actions for the React components to bind.