> ## Documentation Index
> Fetch the complete documentation index at: https://docs-staging-quickstart-revamp.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> This tutorial demonstrates how to add authorization to an ASP.NET Core Web API application using the standard JWT middleware.
# Add Authorization to Your ASP.NET Core Web API Application
export const LoggedInForm = ({sampleApp}) => {
const LS_APPS_KEY = "auth_demo_apps";
const LS_APP_CFG_KEY = "auth_demo_app_cfg";
const CHANNEL = "auth_flows_sync_v1";
const mkChannel = () => new BroadcastChannel(CHANNEL);
function uid() {
return Math.random().toString(36).slice(2) + Date.now().toString(36);
}
function loadApps() {
const raw = localStorage.getItem(LS_APPS_KEY);
if (raw) return JSON.parse(raw);
const seeded = [{
id: "mz9iNEIo2PHu7oeh8QRt19ndTyyCIgai",
name: "Default App"
}];
localStorage.setItem(LS_APPS_KEY, JSON.stringify(seeded));
return seeded;
}
function saveApps(apps) {
localStorage.setItem(LS_APPS_KEY, JSON.stringify(apps));
}
function loadCfg() {
const raw = localStorage.getItem(LS_APP_CFG_KEY);
return raw ? JSON.parse(raw) : {};
}
function saveCfg(cfg) {
localStorage.setItem(LS_APP_CFG_KEY, JSON.stringify(cfg));
}
const RightChevron = ({className = "w-5 h-5", ...props}) => ;
const LightningIcon = () => ;
const LayersIcon = () => ;
const GithubIcon = () => ;
function IconTile({children}) {
return
{children}
;
}
function Card({className = "", children}) {
return
{children}
;
}
function Button({variant = "primary", type = "button", onClick, children}) {
const base = "inline-flex items-center justify-center gap-2 h-10 px-4 rounded-xl font-medium transition";
let styles = "";
if (variant === "primary") {
styles = "mint-bg-indigo-600 text-white hover:mint-bg-indigo-700";
} else if (variant === "outline") {
styles = "border border-zinc-300 dark:border-zinc-700 mint-bg-transparent hover:mint-bg-zinc-50 dark:hover:mint-bg-zinc-800";
} else if (variant === "ghost") {
styles = "hover:mint-bg-zinc-100 dark:hover:mint-bg-zinc-800";
}
return ;
}
function Input({id, label, value, onChange, placeholder, name}) {
return ;
}
function Select({label, value, onChange, options}) {
return ;
}
function Toast({open, onClose, children}) {
useEffect(() => {
if (!open) return;
const t = setTimeout(onClose, 2200);
return () => clearTimeout(t);
}, [open, onClose]);
return
Sign up for an{" "}
Auth0 account
{" "}
or{" "}
console.log("log in")}>
log in
{" "}
to your existing account to integrate directly with your own tenant.
;
};
export const sections = [{
id: "define-permissions",
title: "Define permissions"
}, {
id: "install-dependencies",
title: "Install dependencies"
}, {
id: "configure-the-middleware",
title: "Configure the middleware"
}, {
id: "validate-scopes",
title: "Validate scopes"
}, {
id: "protect-api-endpoints",
title: "Protect API endpoints"
}, {
id: "call-your-api",
title: "Call your API"
}];
Auth0 allows you to add authentication and access user profile information in almost any application type quickly.
This guide demonstrates how to integrate Auth0 with any new or existing ASP.NET Web API application using the
`Microsoft.AspNetCore.Authentication.JwtBearer` package.
If you haven't created an API in your Auth0 dashboard yet, you can use the interactive selector to create a new
Auth0 API or select an existing API that represents the project you want to integrate with.
Alternatively, you can read our getting started guide,
which will help you set up your first API through the Auth0 Dashboard.
Note that every API in Auth0 is configured using an API Identifier; your application code will use the API
Identifier as the Audience to validate the access token.
**New to Auth0?** Learn how Auth0 works and
read about implementing API authentication and
authorization using the OAuth 2.0 framework.
Permissions let you define how resources can be accessed on behalf of the user with a given access token. For
example, you might choose to grant read access to the `messages` resource if users have the manager
access level, and grant write access to that resource if they have the administrator access level.
You can define allowed permissions in the **Permissions** view of the Auth0 Dashboard's [APIs](https://manage.auth0.com/#/apis) section. The following
example uses the `read:messages` scope.
To allow your application to validate access tokens, add a reference to the
`Microsoft.AspNetCore.Authentication.JwtBearer` NuGet package:
```
Install-Package Microsoft.AspNetCore.Authentication.JwtBearer
```
Set up the authentication middleware by configuring it in your application's `Program.cs` file:
1. Register the authentication services by making a call to the `AddAuthentication` method. Configure
`JwtBearerDefaults.AuthenticationScheme` as the default scheme.
2. Register the JWT Bearer authentication scheme by making a call to the `AddJwtBearer` method.
Configure your Auth0 domain as the authority and your Auth0 API Identifier as the audience, and be sure that
your Auth0 domain and API Identifier are set in your application's **appsettings.json** file.
In some cases, the access token will not have a `sub` claim; in this case, the
`User.Identity.Name` will be `null`. If you want to map a different claim to
`User.Identity.Name`, add it to `options.TokenValidationParameters` within the
`AddJwtBearer()` call.
3. Add the authentication and authorization middleware to the middleware pipeline by adding calls to the
`UseAuthentication`and `UseAuthorization`methods under the
`var app = builder.Build();`method.
To ensure that an access token contains the correct scopes, use [Policy-Based Authorization](https://docs.microsoft.com/en-us/aspnet/core/security/authorization/policies) in the ASP.NET Core:
1. Create a new authorization requirement called `HasScopeRequirement`, which will check whether the
`scope`claim issued by your Auth0 tenant is present, and if so, will check that the claim contains
the requested scope.
2. Under your `Program.cs`file's
`var builder = WebApplication.CreateBuilder(args);`method, add a call to the
`app.AddAuthorization`method.
3. Add policies for scopes by calling `AddPolicy`for each scope.
4. Register a singleton for the `HasScopeHandler`class.
The JWT middleware integrates with the standard ASP.NET Core [Authentication](https://docs.microsoft.com/en-us/aspnet/core/security/authentication/) and [Authorization](https://docs.microsoft.com/en-us/aspnet/core/security/authorization/) mechanisms.
To secure an endpoint, add the `[Authorize]` attribute to your controller action (or the entire
controller if you want to protect all of its actions).
When securing endpoints that require specific scopes, make sure that the correct scope is present in the
`access_token`. To do so, add the `Authorize` attribute to the `Scoped` action
and pass `read:messages` as the `policy` parameter.
The way in which you call your API depends on the type of application you are developing and the framework you
are using. To learn more, read the relevant application Quickstart:
* [Single-Page Applications](/docs/quickstart#single-page-app)
* [Mobile / Native Application](/docs/quickstart#native-mobile-app)
### Get an access token
Regardless of the type of application you are developing or the framework you are using, to call your API, you
need an access token.
If you call your API from a Single-Page Application (SPA) or Native application, you will receive an access token
after the authorization flow completes.
If you call the API from a command-line tool or other service where a user entering credentials does not exist,
use the [OAuth Client
Credentials Flow](https://auth0.com/docs/api/authentication#client-credentials). To do so, register a [Machine-to-Machine Application](https://manage.auth0.com/#/applications) and pass the following values in your request:
* **Client ID** as the `client_id` parameter.
* **Client Secret** as the `client_secret` parameter.
* **API Identifier** (the same value used to configure the middleware earlier in this quickstart) as the
`audience` parameter.
To learn more about getting the Client ID and Client Secret for your machine-to-machine application,
read Application Settings.
**Example request**
```sh cURL lines
curl --request post \
--url 'https://dev-gja8kxz4ndtex3rq.us.auth0.com/oauth/token' \
--header 'content-type: application/x-www-form-urlencoded'
```
```cs C# lines
var client = new RestClient("https://dev-gja8kxz4ndtex3rq.us.auth0.com/oauth/token");
var request = new RestRequest(Method.POST);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
IRestResponse response = client.Execute(request);
```
```go Go lines
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://dev-gja8kxz4ndtex3rq.us.auth0.com/oauth/token"
req, _ := http.NewRequest("post", url, nil)
req.Header.Add("content-type", "application/x-www-form-urlencoded")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}
```
```java Java lines
HttpResponse response = Unirest.post("https://dev-gja8kxz4ndtex3rq.us.auth0.com/oauth/token")
.header("content-type", "application/x-www-form-urlencoded")
.asString();
```
```js Node.JS lines
var axios = require("axios").default;
var options = {
method: 'post',
url: 'https://dev-gja8kxz4ndtex3rq.us.auth0.com/oauth/token',
headers: {'content-type': 'application/x-www-form-urlencoded'}
};
axios.request(options).then(function (response) {
console.log(response.data);
}).catch(function (error) {
console.error(error);
});
```
```obj-c Obj-C lines
#import
NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://dev-gja8kxz4ndtex3rq.us.auth0.com/oauth/token"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"post"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume];
```
```php PHP lines
$curl = curl_init();
curl_setopt_array($curl, [
CURLOPT_URL => "https://dev-gja8kxz4ndtex3rq.us.auth0.com/oauth/token",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "post",
CURLOPT_HTTPHEADER => [
"content-type: application/x-www-form-urlencoded"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}
```
```python Python lines
import http.client
conn = http.client.HTTPSConnection("")
headers = { 'content-type': "application/x-www-form-urlencoded" }
conn.request("post", "/dev-gja8kxz4ndtex3rq.us.auth0.com/oauth/token", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```rb Ruby lines
require 'uri'
require 'net/http'
require 'openssl'
url = URI("https://dev-gja8kxz4ndtex3rq.us.auth0.com/oauth/token")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
response = http.request(request)
puts response.read_body
```
```swift Swift lines
require 'uri'
require 'net/http'
require 'openssl'
url = URI("https://dev-gja8kxz4ndtex3rq.us.auth0.com/oauth/token")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
response = http.request(request)
puts response.read_body
```
### Call a secure endpoint
Now that you have an access token, you can use it to call secure API endpoints. When calling a secure endpoint,
you must include the access token as a Bearer token in the **Authorization** header of the request. For
example, you can make a request to the `/api/private` endpoint:
```sh cURL lines
curl --request get \
--url http://localhost:3010/api/private \
--header 'authorization: Bearer YOUR_ACCESS_TOKEN'
```
```cs C# lines
var client = new RestClient("http://localhost:3010/api/private");
var request = new RestRequest(Method.GET);
request.AddHeader("authorization", "Bearer YOUR_ACCESS_TOKEN");
IRestResponse response = client.Execute(request);
```
```go Go lines
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "http://localhost:3010/api/private"
req, _ := http.NewRequest("get", url, nil)
req.Header.Add("authorization", "Bearer YOUR_ACCESS_TOKEN")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}
```
```java Java lines
HttpResponse response = Unirest.get("http://localhost:3010/api/private")
.header("authorization", "Bearer YOUR_ACCESS_TOKEN")
.asString();
```
```js Node.JS lines
var axios = require("axios").default;
var options = {
method: 'get',
url: 'http://localhost:3010/api/private',
headers: {authorization: 'Bearer YOUR_ACCESS_TOKEN'}
};
axios.request(options).then(function (response) {
console.log(response.data);
}).catch(function (error) {
console.error(error);
});
```
```obj-c Obj-C lines
#import
NSDictionary *headers = @{ @"authorization": @"Bearer YOUR_ACCESS_TOKEN" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:3010/api/private"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"get"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume];
```
```php PHP lines
$curl = curl_init();
curl_setopt_array($curl, [
CURLOPT_PORT => "3010",
CURLOPT_URL => "http://localhost:3010/api/private",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "get",
CURLOPT_HTTPHEADER => [
"authorization: Bearer YOUR_ACCESS_TOKEN"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}
```
```python Python lines
import http.client
conn = http.client.HTTPConnection("localhost:3010")
headers = { 'authorization': "Bearer YOUR_ACCESS_TOKEN" }
conn.request("get", "/api/private", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```rb Ruby lines
require 'uri'
require 'net/http'
url = URI("http://localhost:3010/api/private")
http = Net::HTTP.new(url.host, url.port)
request = Net::HTTP::Get.new(url)
request["authorization"] = 'Bearer YOUR_ACCESS_TOKEN'
response = http.request(request)
puts response.read_body
```
```swift Swift lines
import Foundation
let headers = ["authorization": "Bearer YOUR_ACCESS_TOKEN"]
let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:3010/api/private")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "get"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
```
Call the `/api/private-scoped` endpoint in a similar way, but ensure that the API permissions are
configured correctly and that the access token includes the `read:messages` scope.
##### Checkpoint
You should now be able to call the `/api/private` and `/api/private-scoped`
endpoints.
Run your application and verify that:
* `GET /api/private`is available for authenticated requests.
* `GET /api/private-scoped`is available for authenticated requests containing an access
token with the `read:messages`scope.
## Next Steps
Excellent work! If you made it this far, you should now have login, logout, and user profile information running in your application.
This concludes our quickstart tutorial, but there is so much more to explore. To learn more about what you can do with Auth0, check out:
* [Auth0 Dashboard](https://manage.auth0.com/dashboard/us/dev-gja8kxz4ndtex3rq) - Learn how to configure and manage your Auth0 tenant and applications
* [Auth0 Marketplace](https://marketplace.auth0.com/) - Discover integrations you can enable to extend Auth0’s functionality
```cs Program.cs lines highlight={}
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.Authority = $"https://{builder.Configuration["Auth0:Domain"]}/";
options.Audience = builder.Configuration["Auth0:Audience"];
options.TokenValidationParameters = new TokenValidationParameters
{
NameClaimType = ClaimTypes.NameIdentifier
};
});
builder.Services
.AddAuthorization(options =>
{
options.AddPolicy(
"read:messages",
policy => policy.Requirements.Add(
new HasScopeRequirement("read:messages", domain)
)
);
});
builder.Services.AddSingleton();
var app = builder.Build();
app.UseAuthentication();
app.UseAuthorization();
```
```json appsettings.json lines highlight={}
{
"Auth0": {
"Domain": "dev-gja8kxz4ndtex3rq.us.auth0.com",
"Audience": "{yourApiIdentifier}"
}
}
```
```cs HasScopeHandler.cs lines highlight={}
public class HasScopeHandler : AuthorizationHandler
{
protected override Task HandleRequirementAsync(
AuthorizationHandlerContext context,
HasScopeRequirement requirement
) {
// If user does not have the scope claim, get out of here
if (!context.User.HasClaim(c => c.Type == "scope" && c.Issuer == requirement.Issuer))
return Task.CompletedTask;
// Split the scopes string into an array
var scopes = context.User
.FindFirst(c => c.Type == "scope" && c.Issuer == requirement.Issuer).Value.Split(' ');
// Succeed if the scope array contains the required scope
if (scopes.Any(s => s == requirement.Scope))
context.Succeed(requirement);
return Task.CompletedTask;
}
}
```
```cs HasScopeRequirement.cs lines highlight={}
public class HasScopeRequirement : IAuthorizationRequirement
{
public string Issuer { get; }
public string Scope { get; }
public HasScopeRequirement(string scope, string issuer)
{
Scope = scope ?? throw new ArgumentNullException(nameof(scope));
Issuer = issuer ?? throw new ArgumentNullException(nameof(issuer));
}
}
```
```cs ApiController.cs lines highlight={}
[Route("api")]
public class ApiController : Controller
{
[HttpGet("private")]
[Authorize]
public IActionResult Private()
{
return Ok(new
{
Message = "Hello from a private endpoint!"
});
}
[HttpGet("private-scoped")]
[Authorize("read:messages")]
public IActionResult Scoped()
{
return Ok(new
{
Message = "Hello from a private-scoped endpoint!"
});
}
}
```
```cs HasScopeHandler.cs lines highlight={}
public class HasScopeHandler : AuthorizationHandler
{
protected override Task HandleRequirementAsync(
AuthorizationHandlerContext context,
HasScopeRequirement requirement
) {
// If user does not have the scope claim, get out of here
if (!context.User.HasClaim(c => c.Type == "scope" && c.Issuer == requirement.Issuer))
return Task.CompletedTask;
// Split the scopes string into an array
var scopes = context.User
.FindFirst(c => c.Type == "scope" && c.Issuer == requirement.Issuer).Value.Split(' ');
// Succeed if the scope array contains the required scope
if (scopes.Any(s => s == requirement.Scope))
context.Succeed(requirement);
return Task.CompletedTask;
}
}
```
```cs Program.cs lines highlight={}
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.Authority = $"https://{builder.Configuration["Auth0:Domain"]}/";
options.Audience = builder.Configuration["Auth0:Audience"];
options.TokenValidationParameters = new TokenValidationParameters
{
NameClaimType = ClaimTypes.NameIdentifier
};
});
builder.Services
.AddAuthorization(options =>
{
options.AddPolicy(
"read:messages",
policy => policy.Requirements.Add(
new HasScopeRequirement("read:messages", domain)
)
);
});
builder.Services.AddSingleton();
var app = builder.Build();
app.UseAuthentication();
app.UseAuthorization();
```
```json appsettings.json lines highlight={}
{
"Auth0": {
"Domain": "dev-gja8kxz4ndtex3rq.us.auth0.com",
"Audience": "{yourApiIdentifier}"
}
}
```
```cs HasScopeRequirement.cs lines highlight={}
public class HasScopeRequirement : IAuthorizationRequirement
{
public string Issuer { get; }
public string Scope { get; }
public HasScopeRequirement(string scope, string issuer)
{
Scope = scope ?? throw new ArgumentNullException(nameof(scope));
Issuer = issuer ?? throw new ArgumentNullException(nameof(issuer));
}
}
```
```cs ApiController.cs lines highlight={}
[Route("api")]
public class ApiController : Controller
{
[HttpGet("private")]
[Authorize]
public IActionResult Private()
{
return Ok(new
{
Message = "Hello from a private endpoint!"
});
}
[HttpGet("private-scoped")]
[Authorize("read:messages")]
public IActionResult Scoped()
{
return Ok(new
{
Message = "Hello from a private-scoped endpoint!"
});
}
}
```
```cs ApiController.cs lines highlight={}
[Route("api")]
public class ApiController : Controller
{
[HttpGet("private")]
[Authorize]
public IActionResult Private()
{
return Ok(new
{
Message = "Hello from a private endpoint!"
});
}
[HttpGet("private-scoped")]
[Authorize("read:messages")]
public IActionResult Scoped()
{
return Ok(new
{
Message = "Hello from a private-scoped endpoint!"
});
}
}
```
```cs HasScopeHandler.cs lines highlight={}
public class HasScopeHandler : AuthorizationHandler
{
protected override Task HandleRequirementAsync(
AuthorizationHandlerContext context,
HasScopeRequirement requirement
) {
// If user does not have the scope claim, get out of here
if (!context.User.HasClaim(c => c.Type == "scope" && c.Issuer == requirement.Issuer))
return Task.CompletedTask;
// Split the scopes string into an array
var scopes = context.User
.FindFirst(c => c.Type == "scope" && c.Issuer == requirement.Issuer).Value.Split(' ');
// Succeed if the scope array contains the required scope
if (scopes.Any(s => s == requirement.Scope))
context.Succeed(requirement);
return Task.CompletedTask;
}
}
```
```cs Program.cs lines highlight={}
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.Authority = $"https://{builder.Configuration["Auth0:Domain"]}/";
options.Audience = builder.Configuration["Auth0:Audience"];
options.TokenValidationParameters = new TokenValidationParameters
{
NameClaimType = ClaimTypes.NameIdentifier
};
});
builder.Services
.AddAuthorization(options =>
{
options.AddPolicy(
"read:messages",
policy => policy.Requirements.Add(
new HasScopeRequirement("read:messages", domain)
)
);
});
builder.Services.AddSingleton();
var app = builder.Build();
app.UseAuthentication();
app.UseAuthorization();
```
```json appsettings.json lines highlight={}
{
"Auth0": {
"Domain": "dev-gja8kxz4ndtex3rq.us.auth0.com",
"Audience": "{yourApiIdentifier}"
}
}
```
```cs HasScopeRequirement.cs lines highlight={}
public class HasScopeRequirement : IAuthorizationRequirement
{
public string Issuer { get; }
public string Scope { get; }
public HasScopeRequirement(string scope, string issuer)
{
Scope = scope ?? throw new ArgumentNullException(nameof(scope));
Issuer = issuer ?? throw new ArgumentNullException(nameof(issuer));
}
}
```
Sign up for an{" "}
Auth0 account
{" "}
or{" "}
console.log("log in")}>
log in
{" "}
to your existing account to integrate directly with your own tenant.
