diff --git a/articles/quickstart/native/net-android-ios/01-login.md b/articles/quickstart/native/net-android-ios/01-login.md
new file mode 100755
index 0000000000..992d4e2d37
--- /dev/null
+++ b/articles/quickstart/native/net-android-ios/01-login.md
@@ -0,0 +1,227 @@
+---
+title: Add login to your .NET Android or iOS application
+default: true
+description: This tutorial demonstrates how to add user login with Auth0 to a .NET Android or iOS application.
+budicon: 448
+topics:
+ - quickstarts
+ - native
+ - xamarin
+ - dotnet
+ - android
+ - ios
+github:
+ path: Quickstart/01-Login
+contentType: tutorial
+useCase: quickstart
+---
+
+::: note
+This quickstart focusses on .NET Android and iOS, as they are the next generation of `Xamarin.Android` and `Xamarin.iOS`. If you are still using `Xamarin.Android` and `Xamarin.iOS`, you can follow this guide as well as integration is identical and the SDKs are compatible.
+:::
+
+
+
+<%= include('../_includes/_getting_started', { library: 'Xamarin') %>
+
+<%= include('../../../_includes/_callback_url') %>
+
+Callback URLs are the URLs that Auth0 invokes after the authentication process. Auth0 routes your application back to this URL and appends additional parameters to it, including an access code which will be exchanged for an ID Token, Access Token, and Refresh Token.
+
+Since callback URLs can be manipulated, you will need to add your application's URL to your application's *Allowed Callback URLs* for security. This will enable Auth0 to recognize these URLs as valid. If omitted, authentication will not be successful.
+
+* For Android, the callback URL will be in the format
+
+ ```text
+ YOUR_ANDROID_PACKAGE_NAME://${account.namespace}/android/YOUR_ANDROID_PACKAGE_NAME/callback
+ ```
+
+ where `YOUR_ANDROID_PACKAGE_NAME` is the Package Name for your application, such as `com.mycompany.myapplication`.
+
+* For iOS, the callback URL will be in the format
+
+ ```text
+ YOUR_BUNDLE_IDENTIFIER://${account.namespace}/ios/YOUR_BUNDLE_IDENTIFIER/callback
+ ```
+
+ where `YOUR_BUNDLE_IDENTIFIER` is the Bundle Identifier for your application, such as `com.mycompany.myapplication`.
+
+Ensure that the Callback URL is in lowercase.
+
+<%= include('../../../_includes/_logout_url') %>
+
+::: note
+If you are following along with the sample project you downloaded from the top of this page, the logout URL you need to add to the Allowed Logout URLs field is the same as the callback URL.
+:::
+
+## Install Dependencies
+
+${snippet(meta.snippets.dependencies)}
+
+## Trigger Authentication
+
+To integrate Auth0 login into your application, instantiate an instance of the `Auth0Client` class, configuring the Auth0 Domain and Client ID:
+
+${snippet(meta.snippets.setup)}
+
+Then, call the `LoginAsync` method which will redirect the user to the login screen. You will typically do this in the event handler for a UI control such as a Login button.
+
+```cs
+var loginResult = await client.LoginAsync();
+```
+
+### Handing the callback URL
+
+After a user has logged in, they will be redirected back to your application at the **Callback URL** that was registered before. In both Android and iOS you need to handle this callback to complete the authentication flow.
+
+### Android
+
+Register an intent which will handle this callback URL. An easy way to do this is to register the intent on the same activity from which you called the `LoginAsync` method to initiate the authentication flow.
+
+```csharp
+[Activity(Label = "AndroidSample", MainLauncher = true, Icon = "@drawable/icon",
+ LaunchMode = LaunchMode.SingleTask)]
+[IntentFilter(
+ new[] { Intent.ActionView },
+ Categories = new[] { Intent.CategoryDefault, Intent.CategoryBrowsable },
+ DataScheme = "YOUR_ANDROID_PACKAGE_NAME",
+ DataHost = "${account.namespace}",
+ DataPathPrefix = "/android/YOUR_ANDROID_PACKAGE_NAME/callback")]
+public class MainActivity : Activity
+{
+ // Code omitted
+}
+```
+
+Replace `YOUR_ANDROID_PACKAGE_NAME` in the code sample above with the actual Package Name for your application, such as `com.mycompany.myapplication`. Also ensure that all the text for the `DataScheme`, `DataHost`, and `DataPathPrefix` is in lower case. Also, set `LaunchMode = LaunchMode.SingleTask` for the `Activity`, otherwise the system will create a new instance of the activity every time the Callback URL gets called.
+
+Now write code to handle the intent. You can do this by overriding the `OnNewIntent` method. Inside the method you need to call the `Send` method on the `ActivityMediator` to complete the authentication cycle:
+
+```csharp
+protected override async void OnNewIntent(Intent intent)
+{
+ base.OnNewIntent(intent);
+
+ Auth0.OidcClient.ActivityMediator.Instance.Send(intent.DataString);
+}
+```
+
+### iOS
+
+Register the URL scheme for your Callback URL which your application should handle:
+
+1. Open your application's `Info.plist` file in Visual Studio for Mac, and go to the **Advanced** tab.
+2. Under **URL Types**, click the **Add URL Type** button
+3. Set the **Identifier** as `Auth0`, the **URL Schemes** the same as your application's **Bundle Identifier**, and the **Role** as `None`
+
+This is an example of the XML representation of your `info.plist` file after you have added the URL Type:
+
+```xml
+CFBundleURLTypes
+
+
+ CFBundleTypeRole
+ None
+ CFBundleURLName
+ Auth0
+ CFBundleURLSchemes
+
+ YOUR_BUNDLE_IDENTIFIER
+
+
+
+```
+
+You need to handle the Callback URL in the `OpenUrl` event in your `AppDelegate` class. You need to notify the Auth0 OIDC Client to finish the authentication flow by calling the `Send` method of the `ActivityMediator` singleton, pass along the URL that was sent in:
+
+```csharp
+using Auth0.OidcClient;
+
+[Register("AppDelegate")]
+public class AppDelegate : UIApplicationDelegate
+{
+ public override bool OpenUrl(UIApplication application, NSUrl url, string sourceApplication, NSObject annotation)
+ {
+ ActivityMediator.Instance.Send(url.AbsoluteString);
+
+ return true;
+ }
+}
+```
+
+### Run the application
+
+With the above code in place, a user can log in to your application using Auth0.
+
+
+
+