Una Web Api 2 di ASP.NET può essere decorata con degli attributi che permettono di specificare la url a cui dovranno rispondere e/o il mapping dei parametri passati.
Questo metodo sovrascrive le impostazioni di routing effettuate nella classe WebApiConfig.

RoutePrefix può essere usato per decorare il percorso base con cui vengono richiamati i metodi, si applica alla classe:
[RoutePrefix("api/v0")]
public class SgartController : ApiController { .. }

Route, invece, permette di specificare la rimanente parte del percorso legata al singolo metodo:
[Route("getbyid/{idItem}")]
public ServiceStatus GetItem(int idItem) { ... }
il metodo risponderà a un indirizzo nella forma http://nomesito.dominio/api/v0/getbyid/12

Se uso la tilde (~) posso sovrascrivere il RoutePrefix:
[Route("~/api/v1/get/{idItem:int}/item")]
public ServiceStatus GetItem(int idItem) { ... }
Tramite le graffe posso mappare i parametri nella url (vedi esempio precedente) o usarli in Querystring:
[Route("/getbyid?id={idItem:int}")]
public ServiceStatus GetItem(int idItem) { ... }
in questo caso con :int sto specificando un Constraints preso tra quelli di default (il parametro può essere solo un numero intero).

Posso anche indicare il parametro come opzionale (?):
[Route("/getbyid?id={idItem:int?}")]
public ServiceStatus GetItem(int idItem = 0) { ... }
oppure specificare un valore di default
[Route("/getbyid?id={idItem:int=0}")]
public ServiceStatus GetItem(int idItem) { ... }

In ultimo posso usare delle wildcard (*) per mappare il parametro contenente delle slash (/):
[Route("/getbydate/{*date:datetime")]
public ServiceStatus GetItem(DateTime date) { ... }
Il parametro Route può anche essere vuoto
[Route("")]
public ServiceStatus GetItem() { ... }
in questo caso la url sarà uguale al RoutePrefix: http://nomesito.dominio/api/v0.

Posso anche specificare il metodo (GET, POST, ...) con cui richiamarlo:
[HttpGet]
[Route("getbyid/{idItem}")]
public ServiceStatus GetItem(int idItem) { ... }
[HttpPost]
[Route("public/inserted")]
public Models.BO.ServiceStatus PublicInserted([FromBody]string idSession)  { ... }
in questo caso per leggere i paramentri passati in POST devo specificare il parametro [FromBody].
Le decorazioni disponibili per il metodo sono: HttpDelete, HttpGet, HttpHead, HttpOptions, HttpPatch, HttpPost e HttpPut.

Esempio di chiamata ajax in JQuery ad una Web Api 2 in POST:
// api da chiamare
var urlApi = "/api/v0/public/insert";
// esempio di oggetto per la chiamata ajax
var data = {
    url: url,
    data: data,
    dimension: dimension
  };
//chiamata ajax con jquery
$.ajax({
  type: "POST",
  url: urlApi ,
  data: JSON.stringify(data),  //serializzo l'oggetto in json
  contentType: "application/json; charset=utf-8",
  dataType: "json",
  success: function (response) {
    // gestione risposta;
  },
  failure: function (errMsg) {
    // gestione errore;
  }
});
la chiamata è in POST e passa un oggetto Json.
Per leggere il valore lato server posso usare il tipo JObject, decorato con FromBody, e successivamente il metodo GetValue per leggere le singole proprietà:
[HttpPost]
[Route("public/insert")]
public BO.ServiceStatus PublicInsert([FromBody]Newtonsoft.Json.Linq.JObject obj)
{
  string url = (string)obj.GetValue("url", StringComparison.InvariantCultureIgnoreCase); //se non trovato null
  string data= (string)obj.GetValue("url", StringComparison.InvariantCultureIgnoreCase); //se non trovato null
  int? dimension = (int?)obj.GetValue("dimension", StringComparison.InvariantCultureIgnoreCase); //se non trovato null
  ...
In alternativa a JObject posso creare un oggetto specifico che rappresenta il Json in ingresso:
public class MyInputData
{
  public string url {get; set;}
  public string data {get; set;}
  public int dimension {get; set;}
}
[HttpPost]
[Route("public/insert")]
public BO.ServiceStatus PublicInsert([FromBody]MyInputData inputData)
{
  string url = inputData.url;
  string data= inputData.data;
  int dimension = inputData.dimension;
  ...
notare che le proprietà dell'oggetto MyInputData sono scritte in minuscolo come l'oggetto JavaScript
Si può usare Newtonsoft.Json e il decoratore JsonProperty per cambiare il nome alle proprietà serializzate in Json:
using Newtonsoft.Json;

public class MyInputData
{
  [JsonProperty("url")]
  public string Url {get; set;}

  [JsonProperty("data")]
  public string Data {get; set;}

  [JsonProperty("Dimension ")]
  public int Dimension {get; set;}

  [JsonIgnore]
  public int NonSerializzataInJson {get; set;}
}

Vedi anche Attribute Routing in ASP.NET Web API 2 e Parameter Binding in ASP.NET Web API