# Get Started

Welcome to the NOTO API documentation.

## What is <mark style="color:green;">NOTO</mark>?

NOTO is a B2B service that offers a unified resolution service for Web3 domains. It based on:

* A blockchain crawler maintaining an always up-to-date map of Web3 domains across all blockchains
* A patent-pending scoring mechanism that provides guidance in handling collisions and managing abuse signals related to Web3 domains
* A reliable distribution mechanism that provides access to detailed information about Web3 domains via API or through DNS zone files

## Who is <mark style="color:green;">NOTO</mark> for?

* Developers and companies that want to resolve Web3 domains from any provider/blockchain in their applications from multiple providers
* Providers of DNS resolution service that want to enable their users to resolve Web3 domains easily through the same DNS servers they already use for Web2 domains
* Researchers and Academics that study the development of Web3 and need comprehensive access to quality data for their research
* IP and Legal professionals that want to monitor activity on Web3 domains, get signals about potentially abusive use of Web3 domains

PLEASE NOTE

NOTO is currently in Private Beta and only available to selected Partners. If you'd like to find out more and request access to the platform, please [contact our team](https://noto.network/contact/).


# Create your Account

Once you have received your invite to join the NOTO Private Beta, you will be able to register your account on the platform.

1. Type your Full Name, Email, and a Password&#x20;
2. &#x20;Check the box after reading Terms and Conditions
3. Click Sign Up

<figure><img src="/files/8DlWeoflxT5Bi68Ot9YJ" alt=""><figcaption></figcaption></figure>

**A Confirmation** will be sent to your Email, to ensure you are actually the owner of that email address, \
***Click on Verify email address***.

A short survey will be prompted, serves to customise your experience on the platform, \
answer the question and click Next.


# Create your Project

In the [homepage](https://app.noto.network/), click `New Project` and choose a name.

Once a project is created, you can see the project's `Dashboard` with key usage statistics.

<figure><img src="/files/OG9qPCv9nYkXDoTC7h4t" alt=""><figcaption></figcaption></figure>


# Resolution Settings

In this section you can select the Network(s) and Blockchain(s) you want to support in your project, and which ones you want to disable. You find the list of currently supported options in the documentation pages for [providers](/noto-api-docs/api-reference/supported-domain-namespaces) and [blockchains](/noto-api-docs/api-reference/supported-networks).

\
These settings affect the response you will get when asking our APIs to resolve domains.

{% hint style="warning" %}
ATTENTION: Choosing multiple options may lead into a collision, see the [dedicated section](/noto-api-docs/get-started/create-your-project/collision-management) for details.
{% endhint %}

<figure><img src="/files/WBIYI7InomxxbL69v7oE" alt=""><figcaption></figcaption></figure>


# Collision Management

The Collision Management of your Noto project

When the same Web3 domain exists in multiple blockchains or namespaces, a collision occurs.

NOTO includes a patent-pending scoring algorithm that provides guidance on the status of each domain to help pick the most relevant option.

Partners can customize how the domain scoring works. Among other things, you can raise the priority of certain providers or create custom rules and exceptions:

* Add Exception -> type the Domain or TLD *(e.g. ".com" is a TLD )* and choose your preferred Namespace for it and -> Click Save.

<figure><img src="/files/lcmvQKDAw9GNRJW2mFqv" alt=""><figcaption></figcaption></figure>


# Team

The team section of your Noto project

In this section you are able to <mark style="color:orange;">**Manage your team**</mark> by adding or removing team member emails and giving them a role, with associated permits.

<figure><img src="/files/ncINH0B30cZhFg7t9Udd" alt=""><figcaption></figcaption></figure>


# API Keys

The API keys of your Noto project

On this page you can see your active API keys or create new ones.

<figure><img src="/files/FiVJOjm8BPat0GwR1VSe" alt=""><figcaption></figcaption></figure>

-> Click on <mark style="color:orange;">**Security**</mark> to manage allowed IP address, allowed origins and view your plan limits.

<figure><img src="/files/AGzRVFINZQjoXx62JEXT" alt=""><figcaption></figcaption></figure>


# Settings

The settings of your Noto project

Under Settings, you can:

* Change project's name and description
* View Quota Consumed and Creation Date
* Delete the project

<figure><img src="/files/TRfFUBNStpuyHW6VUfCf" alt=""><figcaption></figcaption></figure>


# API Reference

The following sections will provide you a quick and straightforward explanation of the **REST NOTO API** endpoint with practical and ready-to-use examples.

### The API offers the following endpoints:

<details>

<summary><a href="/pages/aVtXMHsw5w7f60L3X4NT">Resolve</a></summary>

Fetch all records corresponding to the Domain Name in the request, e.g. example.tld\
In case the domain exists in multiple blockchains/namespace, this endpoint returns only the domain with the highest score, based on the NOTO scoring algorithm and/or your custom collision rule, [more info here](/noto-api-docs/api-reference/scoring-mechanism)

You can also specify a Network and/or a Provider in the API call to limit the search to those specific Network/Provider.

</details>

<details>

<summary><a href="/pages/CU2WahAU4XSozh6cZWpd">Deep Resolve</a></summary>

Fetch all records corresponding to the Domain Name in the request, e.g. example.tld\
In case the domain exists in multiple blockchains/namespace, this endpoint returns an array of all the matching records, ordered based on the NOTO scoring algorithm and/or your custom collision rule, [more info here](/noto-api-docs/api-reference/scoring-mechanism)

You can also specify a Network and/or a Provider in the API call to limit the search to those specific Network/Provider.

</details>

<details>

<summary><a href="/pages/WJMUOopaj4GrgfXRxjqd">Reverse Resolve</a></summary>

Search for Web3 domains by passing the On-Chain Address.\
This is the implementation of [Reverse DNS Lookup](https://en.wikipedia.org/wiki/Reverse_DNS_lookup), instead of using an IP address, you provide a Blockchain Address.

You can also specify a Network and/or a Provider in the API call to limit the search to those specific Network/Provider.

</details>

### Since each endpoint has a different scope, the body of the response will change accordingly, what will not change is the structure of each Record returned

{% hint style="warning" %}
The content of the record may vary depending on the domain. The following keys are always returned for each query:

* info
* records
* fullQualifiedDomain
* network
* provider
* ownerAddress
* score
* spam
  {% endhint %}

```json
{
  "info":{
    "sld":"example",
    "tld":"tld",
    "smartContractAddress":"0x0000000000000000000000000000000000000000",
    "lastUpdate":"2024-02-02T17:58:39.330Z",
    "CSAMValidation":false,
    "KYC":false,
    "tags":[]
  },
  "records":{
    // if any records exist, will look like this example
    "redirect.WEBSITE.0": "https://freename.io",
    "profile.OWNER.fullname": "John Doe",
    "record.TXT.0": "https://ex.ample/",
    "record.A.0": "30.25.212.37"
    "token.ETH.0":"0x0000000000000000000000000000000000000000",
    ...
  },
  "fullQualifiedDomain":"example.tld",
  "network":"POLYGON",
  "provider":"FREENAME",
  "ownerAddress":"0x0000000000000000000000000000000000000000",
  "score":0,
  "spam":false
}
```


# Authentication

You need to authenticate every request to the NOTO API using your API Key ([find out how to create an API key](/noto-api-docs/get-started/create-your-project/api-keys)).

The API key should be passed in the Header of the request, using the key:`api-key`\
\
Here you can see a example in Bash:

```bash
# CHANGE ME
url="https://engine.noto.network/noto/api/v1/resolve?fullQualifiedDomain=example.tld"
# CHANGE ME
api_key="your_api_key"

curl -X GET -H "api-key: $api_key" $url
```

### Here you can see additional examples in the following languages:

<details>

<summary>Node.js</summary>

```javascript
const fetch = require('node-fetch');

// CHANGE ME
const url = 'https://engine.noto.network/noto/api/v1/resolve?fullQualifiedDomain=example.tld'; 
// CHANGE ME
const api_key = 'your_api_key';

async function fetchData(url, api_key) {
    try {
        const response = await fetch(url, {
            method: 'GET',
            headers: { 'api-key': api_key }
        });
        if (!response.ok) throw new Error('Error: network response');
        const data = await response.json();
        console.log('Server response:', data);
    } catch (error) {
        console.error('Fetch error:', error);
    }
}

// CALL FUNCTION
fetchData();
```

</details>

<details>

<summary>Python</summary>

```python
import requests

# CHANGE ME
url = "https://engine.noto.network/noto/api/v1/resolve?fullQualifiedDomain=example.tld"
# CHANGE ME
api_key = "your_api_key"

headers = {"api-key": api_key}

try:
    response = requests.get(url, headers=headers)
    response.raise_for_status()
    print(response.json())
except requests.exceptions.HTTPError as errh:
    print("An HTTP error occurred:", errh)
except requests.exceptions.RequestException as err:
    print("A Request error occurred:", err)
```

</details>

<details>

<summary>Go</summary>

```go
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    // CHANGE ME
    url := "https://engine.noto.network/noto/api/v1/resolve?fullQualifiedDomain=example.tld"
    // CHANGE ME
    api_key := "your_api_key"

    client := &http.Client{}
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }

    req.Header.Add("api-key", api_key)

    res, err := client.Do(req)
    if err != nil {
        fmt.Println("Error making request:", err)
        return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
        fmt.Println("Error reading response body:", err)
        return
    }

    fmt.Println("Server response:", string(body))
}
```

</details>

<details>

<summary>C#</summary>

```csharp
using System;
using System.IO;
using System.Net;

class Program
{
    static void Main()
    {
        // CHANGE ME
        string url = "https://engine.noto.network/noto/api/v1/resolve?fullQualifiedDomain=example.tld";
        // CHANGE ME
        string api_key = "your_api_key";

        try
        {
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
            request.Method = "GET";
            request.Headers.Add("api-key", api_key);

            using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
            using (Stream stream = response.GetResponseStream())
            using (StreamReader reader = new StreamReader(stream))
            {
                Console.WriteLine(reader.ReadToEnd());
            }
        }
        catch (WebException e)
        {
            Console.WriteLine("An error occurred while connecting to the API.");
            Console.WriteLine(e.Message);
            if (e.Response != null)
            {
                using (Stream stream = e.Response.GetResponseStream())
                using (StreamReader reader = new StreamReader(stream))
                {
                    Console.WriteLine("Response from server:");
                    Console.WriteLine(reader.ReadToEnd());
                }
            }
        }
        catch (Exception e)
        {
            Console.WriteLine("A general error occurred.");
            Console.WriteLine(e.Message);
        }
    }
}

```

</details>

<details>

<summary>Java</summary>

```java
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class Main {
    public static void main(String[] args) {
        // CHANGE ME
        String url = "https://engine.noto.network/noto/api/v1/resolve?fullQualifiedDomain=example.tld";
        // CHANGE ME 
        String api_key = "your_api_key"; 

        try {
            URL obj = new URL(url);
            HttpURLConnection connection = (HttpURLConnection) obj.openConnection();

            connection.setRequestMethod("GET");
            connection.setRequestProperty("api-key", api_key);

            BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String inputLine;
            StringBuilder response = new StringBuilder();

            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
            in.close();

            System.out.println(response.toString());
        } catch (Exception e) {
            System.out.println("An error occurred: " + e.getMessage());
            e.printStackTrace();
        }
    }
}
```

</details>


# Endpoints

This section contains the NOTO endpoints, let's explore them together


# Resolve

Fetch all records corresponding to the Domain Name in the request, e.g. example.tld\
In case the domain exists in multiple blockchains/namespace, this endpoint returns only the domain with the highest score, based on the NOTO scoring algorithm and/or your custom collision rule, [more info here](/noto-api-docs/api-reference/scoring-mechanism)

You can also specify a Network and/or a Provider in the API call to limit the search to those specific Network/Provider.

### **Endpoint:** <mark style="color:blue;background-color:green;">`engine.noto.network/noto/api/v1/resolve`</mark>

### **Method:** <mark style="color:green;">`GET`</mark>

### **Parameters:**

<table><thead><tr><th width="200">Param name</th><th width="89">Type</th><th width="101">Required</th><th width="163">Addition Info</th><th>Example</th></tr></thead><tbody><tr><td>domain</td><td>String</td><td>✅</td><td></td><td>example.tld</td></tr><tr><td>network</td><td>String</td><td><em>optional</em></td><td><a href="/pages/PqmSBU34PbDs3EoGVNN5">Available Options</a></td><td><code>POLYGON</code></td></tr><tr><td>provider</td><td>String</td><td><em>optional</em></td><td><a href="/pages/kxFbE8O1mTaSKPhA40xQ">Available Options</a></td><td><code>FREENAME</code></td></tr></tbody></table>

## Return type: <mark style="color:orange;">**OBJECT**</mark>

### **Request Example:**

{% code fullWidth="false" %}

```http
GET /noto/api/v1/resolve?domain=example.eth&network=POLYGON&provider=FREENAME
```

{% endcode %}

### Response Example:

```json
{
    "result":true,
    "data":{
        "info":{
            "sld":"example",
            "tld":"tld""smartContractAddress":"0x0000000000000000000000000000000000000000",
            "lastUpdate":"2024-02-02T17:58:39.330Z",
            "CSAMValidation":false,
            "KYC":false,
            "tags":[]
        },
        "records":{
          // if any records exist, will look like this example
          "redirect.WEBSITE.0": "https://freename.io",
          "profile.OWNER.fullname": "John Doe",
          "record.TXT.0": "https://ex.ample/",
          "record.A.0": "30.25.212.37"
          "token.ETH.0":"0x0000000000000000000000000000000000000000",
          ...
        },
        "domain":"example.tld",
        "network":"POLYGON",
        "provider":"FREENAME",
        "ownerAddress":"0x0000000000000000000000000000000000000000",
        "score":0,
        "spam":false
    }
}
```


# Deep Resolve

Fetch all records corresponding to the Domain Name in the request, e.g. example.tld\
In case the domain exists in multiple blockchains/namespace, this endpoint returns an array of all the matching records, ordered based on the NOTO scoring algorithm and/or your custom collision rule, [more info here](/noto-api-docs/api-reference/scoring-mechanism)

You can also specify a Network and/or a Provider in the API call to limit the search to those specific Network/Provider.

### **Endpoint:** <mark style="color:blue;background-color:green;">`engine.noto.network/noto/api/v1/deep-resolve`</mark>

### **Method:** <mark style="color:green;">`GET`</mark>

### **Parameters:**

<table><thead><tr><th width="200">Param name</th><th width="89">Type</th><th width="101">Required</th><th width="163">Addition Info</th><th>Example</th></tr></thead><tbody><tr><td>domain</td><td>String</td><td>✅</td><td></td><td>example.tld</td></tr><tr><td>network</td><td>String</td><td><em>optional</em></td><td><a href="/pages/PqmSBU34PbDs3EoGVNN5">Available Options</a></td><td><code>POLYGON</code></td></tr><tr><td>provider</td><td>String</td><td><em>optional</em></td><td><a href="/pages/kxFbE8O1mTaSKPhA40xQ">Available Options</a></td><td><code>FREENAME</code></td></tr></tbody></table>

## Return type: <mark style="color:orange;">**ARRAY of OBJECTs**</mark>

### **Request Example:**

{% code fullWidth="false" %}

```http
GET /noto/api/v1/deep-resolve?domain=example.tld&network=POLYGON&provider=FREENAME
```

{% endcode %}

### Response Example:

```json
{
  "result": true,
  "data": [
    {
      "info": {
        "sld": "example",
        "tld": "tld",
        "smartContractAddress": "0x48Fd97F28128DBc661F62Bae6AA925b15928dDde",
        "lastUpdate": "2024-02-03T08:59:25.040Z",
        "CSAMValidation": false,
        "KYC": false,
        "tags": []
      },
      "records":{
        // if any records exist, will look like this example
        "redirect.WEBSITE.0": "https://freename.io",
        "profile.OWNER.fullname": "John Doe",
        "record.TXT.0": "https://ex.ample/",
        "record.A.0": "30.25.212.37"
        "token.ETH.0":"0x0000000000000000000000000000000000000000",
        ...
      },
      "domain": "cederico.metaverse",
      "network": "POLYGON",
      "provider": "FREENAME",
      "ownerAddress": "0x673c4F104F425BEB439EdeEF2e22bDFCEdAD0Ac5",
      "score": 100,
      "spam": false
    }, 
    {
      ...
    }, 
    {
      ...
    }
  ]
}
```


# Reverse Resolve

This is an implementation of [Reverse DNS Lookup](https://en.wikipedia.org/wiki/Reverse_DNS_lookup), instead of using an IP address, \
you provide a Blockchain Wallet Address to find Web3 domains associated with the On-Chain Wallet Address provided.

### **Endpoint:** <mark style="color:blue;background-color:green;">`engine.noto.network/noto/api/v1/reverse-resolve`</mark>

### **Method:** <mark style="color:green;">`GET`</mark>

### **Parameters:**

<table><thead><tr><th width="156">Param name</th><th width="94">Type</th><th width="100">Required</th><th width="163">Addition Info</th><th>Example</th></tr></thead><tbody><tr><td>walletAddress</td><td>String</td><td>✅</td><td></td><td>0xab5801a7d398351b8be11c439e05c5b3259aec9b</td></tr><tr><td>network</td><td>String</td><td><em>optional</em></td><td><a href="/pages/PqmSBU34PbDs3EoGVNN5">Available Options</a></td><td><code>ETHEREUM</code></td></tr><tr><td>provider</td><td>String</td><td><em>optional</em></td><td><a href="/pages/kxFbE8O1mTaSKPhA40xQ">Available Options</a></td><td><code>FREENAME</code></td></tr></tbody></table>

## Return type: <mark style="color:orange;">**ARRAY of OBJECTs**</mark>

### **Request Example:**

{% code fullWidth="false" %}

```http
GET /reverse-resolve?walletAddress=0xab5801a7d398351b8be11c439e05c5b3259aec9b&network=ETHEREUM&provider=FREENAME
```

{% endcode %}

### **Response Example:**

```json
{
  "result": true,
  "data": [
    {
      "info": {
        "sld": "example",
        "tld": "tld",
        "lastUpdate": "2024-02-03T09:13:30.472Z",
        "CSAMValidation": false,
        "KYC": false,
        "tags": []
      },
      "records":{
        // if any records exist, will look like this example
        "redirect.WEBSITE.0": "https://freename.io",
        "profile.OWNER.fullname": "John Doe",
        "record.TXT.0": "https://ex.ample/",
        "record.A.0": "30.25.212.37"
        "token.ETH.0":"0x0000000000000000000000000000000000000000",
        ...
      },
      "domain": "alessandro.incredibledomain",
      "network": "POLYGON",
      "provider": "FREENAME",
      "ownerAddress": "0x673c4F104F425BEB439EdeEF2e22bDFCEdAD0Ac5",
      "score": 0,
      "spam": false
    },
    {
      ...
    }
  ]
}

```


# Supported Networks

The networks that Noto support

<table><thead><tr><th width="159.33333333333331">Network</th><th width="179">API Param Value</th><th>Additional Info</th><th data-type="files"></th></tr></thead><tbody><tr><td>ETHEREUM </td><td><code>ETHEREUM</code></td><td></td><td></td></tr><tr><td>POLYGON</td><td><code>POLYGON</code></td><td></td><td></td></tr><tr><td>BINANCE SMART CHAIN</td><td><code>BSC</code></td><td></td><td></td></tr><tr><td>AURORA</td><td><code>AURORA</code></td><td></td><td></td></tr><tr><td>SOLANA</td><td><code>SOLANA</code></td><td>(Coming Soon)</td><td></td></tr></tbody></table>


# Supported Domain Namespaces

The Domain namespaces that NOTO support

<table><thead><tr><th width="216.33333333333331">Provider</th><th width="226">API Param Value</th><th>Additional Info</th></tr></thead><tbody><tr><td>FreeName</td><td><code>FREENAME</code></td><td></td></tr><tr><td>Unstoppable Domains</td><td><code>UNSTOPPABLE_DOMAINS</code></td><td></td></tr><tr><td>ENS</td><td><code>ENS</code></td><td></td></tr><tr><td>HNS</td><td><code>HNS</code></td><td>(Coming Soon)</td></tr></tbody></table>


# Scoring Mechanism

The Scoring Mechanism of NOTO

**NOTO** has a built-in <mark style="color:orange;">**Scoring Algorithm.**</mark>

The *score for each domain* is expressed in form of a number (from 0 to 100) and is computed using a set of parameters that include:

* Geographic DNS rules *(e.g. certain words are blocked in some countries)*
* Provider rules
* Your custom [Resolution Settings](/noto-api-docs/get-started/create-your-project/resolution-settings)
* Your custom [Collision Management](/noto-api-docs/get-started/create-your-project/collision-management) settings

The Score is currently used primarily for Domain Resolution to provide an indication of which domain should be used in case of collision between different namespaces.


# Error Handling

## NOTO API follows the standard HTTP Status Codes

## Status Code Categories

<details>

<summary><mark style="color:green;">2xx Success</mark></summary>

This category includes all status for a positive Response, \
meaning your Request is succesfully fullfilled.

</details>

<details>

<summary><mark style="color:red;">4xx Client Error</mark></summary>

When a status code belonging to <mark style="color:red;">4xx</mark> category is returned, it indicates that there some kind of error with the request.

For example:&#x20;

* 400 Bad Request
* 401 Unauthorized (check you are using the api key correctly >  [Auth](/noto-api-docs/api-reference/authentication))
* 404 Not Found
* 429 Too many requests

</details>

<details>

<summary><mark style="color:red;">5xx Server Error</mark></summary>

When a status code belonging to <mark style="color:red;">5xx</mark> category is returned, it means the server encountered some kind of error while processing your request.

</details>

#### If the error persist don't hesitate to contact [our support](/noto-api-docs/contact-and-support)


# Test Web3 domain resolution over DNS

NOTO offers a set of DNS resolvers that can be used for testing purposes.

| Type               | Address                     |
| ------------------ | --------------------------- |
| DNS - over - HTTPS | <https://dns1.noto.network> |
| NS1                | 34.154.40.173               |
| NS2                | 34.154.254.177              |

Please bear in mind that:

* Being able to fully interact with a Web3 domain depends only in part on its resolution, whether this happens directly from the blockchain or via a DNS query on our nameservers. This depends on factors such as the browser or application you are using and it is beyond the control of Freename.
* These DNS servers are intended to facilitate testing but are not meant to permanently replace the DNS server provided by your ISP. Should you have any issues while using the Freename DNS, please switch back to your original DNS configuration.

<br>


# FAQs

Welcome to NOTO FAQ section. Here, you'll find answers to commonly asked questions about our project, services, and the technology we've implemented.


# NOTO

<details>

<summary>What is NOTO?</summary>

Noto is a B2B service that offers a unified resolution service for Web3 domains. It based on:

* A blockchain crawler maintaining an always up-to-date map of Web3 domains across all blockchains
* A patent-pending scoring mechanism that provides guidance in handling collisions and managing abuse signals related to Web3 domains
* A reliable distribution mechanism that provides access to detailed information about Web3 domains via API or through DNS zone files

</details>

<details>

<summary>Who is NOTO for?</summary>

NOTO can be an extremely useful tool for:

* Developers and companies that want to resolve web3 domains from any provider/blockchain in their applications from multiple providers.
* Providers of DNS resolution service that want to enable their users to resolve Web3 domains easily through the same DNS servers they already use for Web2 domains
* Researchers and Academics that study the development of Web3 and need comprehensive access to quality data for their research.
* IP and Legal professionals that want to monitor activity on Web3 domains and get signals about potentially abusive use of Web3 domains.

</details>

<details>

<summary>How can I integrate NOTO in my project?</summary>

You can integrate NOTO in your project in 2 different ways:

* Use the NOTO API. Use our simple REST API to perform searches on specific domain names and get full details on them.
* Use the NOTO DNS. NOTO allows you to export the data about the Web3 domains in the database in the format of a zonefile. This can then be easily imported into your existing DNS resolver to offer easy and fast Web3 resolution service to your users.

</details>

<details>

<summary>How can I get access to NOTO?</summary>

NOTO is currently in private beta. We welcome [expressions of interest](https://noto.network/contact/) from Network Operators, VPN and DNS providers and application developers as well as Researchers and Academics interested in getting full access to the NOTO backend and API.

We are also making a set of DNS resolvers publicly available to allow interested third parties to test the DNS resolution option offered by NOTO. More details on this are available in the documentation portal.

</details>


# DNS

<details>

<summary>What is DNS?</summary>

DNS stands for Domain Name System. It is an essential component of the internet, functioning like a phonebook for the internet. The DNS translates domain names that are easy for humans to remember, like [www.example.com](http://www.example.com), into the numerical IP addresses needed for locating and identifying computer services and devices with the underlying network protocols. When you type a website address in your browser, the DNS servers take that domain name and translate it to its corresponding IP address so your browser can load the website. This system is crucial for the smooth functioning of the internet, allowing users to access websites using familiar domain names rather than complex numerical IP addresses.

</details>

<details>

<summary>How can I browse Web3 Domains?</summary>

If you operate DNS resolvers, NOTO allows you to export data about Web3 domains in a standard zonefile format that can easily import into your own nameservers. You can also use our test DNS servers to run individual queries to test how the system behaves and what responses to expect.

</details>


# Web3 Domains

<details>

<summary>What are Web3 Domains?</summary>

Web3 Domains are a new type of domain name that exists on blockchain technology. Unlike traditional domain names managed by centralized organizations like ICANN, Web3 Domains are decentralized. This means they are registered on a blockchain, which offers several unique benefits. Firstly, once you purchase a Web3 domain, it's yours perpetually without the need for annual renewals. Secondly, these domains can act as both a website address and a cryptocurrency wallet address, simplifying transactions. They are resistant to censorship and can be integrated with decentralized applications (dApps), making them a key component in the emerging Web3 space, which emphasizes a decentralized internet.

Considering that Web3 Domains are not organized and coordinated by a central entity like ICANN, it means that they may differ in standard of technology used, features but most importantly they can have naming collision, enabling different owners of a web3 domain to collide between each other in deciding which one has the right to be resolved.

</details>

<details>

<summary>How Do Web3 Domains Work?</summary>

Web3 Domains are registered on blockchain networks. Once registered, they are associated with a public wallet address rather than being managed by traditional DNS servers. This integration with blockchain technology allows for direct peer-to-peer interactions, decentralized hosting, and can facilitate crypto transactions.

</details>

<details>

<summary>What are the Benefits of Using Web3 Domains?</summary>

Benefits include enhanced security against domain hijacking, censorship resistance, simplified cryptocurrency transactions (using the domain as a wallet address), and complete control over the domain without reliance on a central authority.

</details>

<details>

<summary>Can Web3 Domains Be Used Like Traditional Domains?</summary>

Yes and no. They can be used for hosting websites, but they require specific browsers or extensions to resolve, as they are not part of the traditional DNS. However, they are more commonly used for simplifying crypto transactions.

</details>

<details>

<summary>Where can I buy a Web3 Domain?</summary>

Visit [https://freename.io](htps://freename.io) to purchase your domain. You can choose from a variety of options and themes, something to fit your lifestyle, intuition and needs.

</details>


# Collision Management

<details>

<summary>What is a Domain Name Collision?</summary>

A domain name collision occurs when a domain with the same Domain Name and Top Level Domain exists in two different namespaces on the same blockchain.

</details>

<details>

<summary>How do you manage Domain Collision?</summary>

Our algorithm scores Web3 domain name based on a number of different parameters. NOTO users can then handle the collisions automatically by returning the domain with the highest score, or customize their settings to influence the score or limit the results to specific blockchains/namespaces.

</details>

<details>

<summary>How Can I Prevent Domain Collisions in My Network?</summary>

To prevent collisions, if you are using NOTO APIs, configure your Resolution and Collision Settings on your project [Collision Management](/noto-api-docs/get-started/create-your-project/collision-management). For NOTO DNS, the domain will always return only the domain with the highest score. In the future, you will be able to tweak the settings of how your zonefile is generated similarly to what you can already do when using the API.

</details>


# Contact and Support

For inquiry and further help, contact us at: <mailto:support@noto.network>