question

Hi, you can use System.Net.Http.HttpClient.GetAsync like in following demo. Only NewtonSoft.Json is necessary.

 <Window x:Class="WpfApp1.Window03"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
         xmlns:local="clr-namespace:WpfApp03"
         mc:Ignorable="d"
         Title="Window03" Height="450" Width="800">
   <Window.DataContext>
     <local:ViewModel/>
   </Window.DataContext>
   <Grid>
     <DataGrid Name="DGD_UserList" 
               AutoGenerateColumns="False"  
               ItemsSource="{Binding ContentModels}">
       <DataGrid.Columns>
         <DataGridTextColumn Binding="{Binding Name}" Header="Object Id" IsReadOnly="True"/>
         <DataGridTextColumn Binding="{Binding ProductUrl}" Header="Continent" IsReadOnly="True"/>
       </DataGrid.Columns>
     </DataGrid>
   </Grid>
 </Window>

 using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
 using System.Net.Http;
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows;
    
 namespace WpfApp03
 {
   public class ViewModel : INotifyPropertyChanged
   {
     public event PropertyChangedEventHandler PropertyChanged;
    
     private static string _RootUrl = @"https://api.predic8.de/shop/products/";
     private AsyncObservableCollection<ContentModel> _ContentModels = null;
    
     public AsyncObservableCollection<ContentModel> ContentModels
     {
       get { return _ContentModels; }
       set { _ContentModels = value; OnPropertyChanged(); }
     }
     public ViewModel() => this.ContentModels = this.GetContentData();
    
     #region "Read"
     private AsyncObservableCollection<ContentModel> GetContentData()
     {
       AsyncObservableCollection<ContentModel> ReturnContentModles = null;
       Task<AsyncObservableCollection<ContentModel>> ContentTask = this.GetContentModels();
       ContentTask.Wait();
       if (ContentTask.Result.Count > 0) ReturnContentModles = ContentTask.Result;
       return ReturnContentModles;
     }
     private async Task<AsyncObservableCollection<ContentModel>> GetContentModels()
     {
       AsyncObservableCollection<ContentModel> ReturnContinentModels = new AsyncObservableCollection<ContentModel>();
       try
       {
         using (HttpClient httpClient = new HttpClient())
         {
           httpClient.DefaultRequestHeaders.Add("Accept", "application/json;charset=UTF-8");
           using (HttpResponseMessage HttpResponseMessage = await httpClient.GetAsync(string.Concat(_RootUrl, ""), HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false))
           {
             if (HttpResponseMessage.StatusCode == System.Net.HttpStatusCode.OK)
               using (HttpContent HttpContent = HttpResponseMessage.Content)
               {
                 string MyContent = await HttpContent.ReadAsStringAsync();
                 var root = JsonConvert.DeserializeObject<RootObject>(MyContent);
                 ReturnContinentModels = new AsyncObservableCollection<ContentModel>(root.products);
               }
           }
         }
       }
       catch (Exception ex) { Console.WriteLine(ex.Message); }
       return ReturnContinentModels;
     }
     #endregion
    
     protected void OnPropertyChanged([CallerMemberName] string propertyName = "") =>
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
   }
    
   public class AsyncObservableCollection<T> : ObservableCollection<T>
   {
     private readonly SynchronizationContext _synchronizationContext = SynchronizationContext.Current;
     public AsyncObservableCollection() { }
     public AsyncObservableCollection(IEnumerable<T> list) : base(list) { }
     private void ExecuteOnSyncContext(Action action)
     {
       if (SynchronizationContext.Current == _synchronizationContext) action();
       else _synchronizationContext.Send(_ => action(), null);
     }
     protected override void InsertItem(int index, T item) => ExecuteOnSyncContext(() => base.InsertItem(index, item));
     protected override void RemoveItem(int index) => ExecuteOnSyncContext(() => base.RemoveItem(index));
     protected override void SetItem(int index, T item) => ExecuteOnSyncContext(() => base.SetItem(index, item));
     protected override void MoveItem(int oldIndex, int newIndex) => ExecuteOnSyncContext(() => base.MoveItem(oldIndex, newIndex));
     protected override void ClearItems() => ExecuteOnSyncContext(() => base.ClearItems());
   }
    
   public class RootObject
   {
     public Meta meta { get; set; }
     public List<ContentModel> products { get; set; }
   }
    
   public class Meta
   {
     public int count { get; set; }
     public int limit { get; set; }
     public int page { get; set; }
     public string next_url { get; set; }
   }
    
   public class ContentModel
   {
     [JsonProperty("name")]
     public string Name { get; set; }
    
     [JsonProperty("product_url")]
     public string ProductUrl { get; set; }
   }
 }