# da.gd

> Shorten links with da.gd, the free and open-source link shortener, and check where a da.gd link goes. It also answers everyday questions about websites and domains: whether a site is up, the headers it sends, the IP addresses and DNS records behind a domain, who owns a domain and when it expires, and which provider runs an IP address. No account or API key required.

App · 8 actions. Web page: https://docs.lodol.com/docs/integrations/da-gd

## Actions

### Check if a website is up

Find out whether a website or page is answering, and with which status, as a visitor on the internet would see it, so a workflow can raise the alarm when a site goes down or a page goes missing. No account or API key required.

**Inputs**

- Website (`url`, text, required): The website or page to check: a domain such as wikipedia.org, or a whole link to one page. An address typed without https:// gets it added.
- Follow redirects (`follow_redirects`, true/false): Follow the site if it sends visitors on to another address, as a browser does, and report on the page they end up at. Turn this off to report on the address exactly as given, such as to check that an old address still redirects. Default: `true`.
- Check the security certificate (`check_certificate`, true/false): Count the site as down when its security certificate is expired or invalid, which is when browsers show visitors a warning instead of the page. Default: `false`.

**Outputs**

- `answered` (true/false): Whether the site answered at all. False means it couldn't be reached: the domain doesn't exist, the server is off, it took too long, or its certificate failed the check.
- `is_up` (true/false): True when the site answered with a page or a redirect (a status below 400); false when it answered with an error or not at all.
- `status_code` (number): The status the site answered with: 200 means the page loaded, 301 and 302 that it sends visitors elsewhere, 404 that the page doesn't exist and 500 or above that the site has a fault. Null when the site didn't answer at all.
- `status_text` (text): The status in words, e.g. OK, Moved Permanently or Not Found. Null when the site didn't answer.
- `url` (text): The address that was checked. One typed without https:// comes back with it added.

**Example output**

```json
{
  "answered": true,
  "is_up": true,
  "status_code": 200,
  "status_text": "OK",
  "url": "https://wikipedia.org"
}
```

### Check where a short link goes

Find the address a da.gd link opens, without opening it: da.gd is asked, so nothing is fetched from the far side and no visit is counted. Safe to run on a link somebody sent you. No account or API key required.

**Inputs**

- Short link (`short_url`, text, required): The da.gd link to look up: the whole link, or just the code at the end of it. Capitals count, so pVl5o and pvl5o are different links.

**Outputs**

- `code` (text): The end of the short link, after da.gd/, e.g. LMbIp. Capitals count.
- `original_url` (text): The address the short link opens: the long link somebody shortened.
- `short_url` (text): The short link, e.g. https://da.gd/LMbIp. Paste this wherever the long one would have gone.

**Example output**

```json
{
  "code": "pVl5o",
  "original_url": "https://example.com/lodol-qa",
  "short_url": "https://da.gd/pVl5o"
}
```

### Get a website's response headers

Read the headers a website sends with its pages, such as its server, caching and security settings, and every redirect on the way to the final page. Useful for checking a site's setup after a change. No account or API key required.

**Inputs**

- Website (`url`, text, required): The website or page to read: a domain such as example.com, or a whole link to one page. An address typed without https:// gets it added.
- Follow redirects (`follow_redirects`, true/false): Follow the site if it sends visitors on to another address, as a browser does, and report on the page they end up at. Turn this off to report on the address exactly as given, such as to check that an old address still redirects. Default: `true`.

**Outputs**

- `final_url` (text): The address of the page the headers are from: the one given, or where its redirects led.
- `headers` (object): Each header by its name in lower case, such as server, content-type or strict-transport-security. A header sent more than once has its values joined with commas.
- `redirects` (list): Each redirect on the way to the final page, in order. Empty when there were none.
- `status_code` (number): The status the site answered with: 200 means the page loaded, 301 and 302 that it sends visitors elsewhere, 404 that the page doesn't exist and 500 or above that the site has a fault. Null when the site didn't answer at all.
- `status_text` (text): The status in words, e.g. OK, Moved Permanently or Not Found. Null when the site didn't answer.
- `url` (text): The address that was checked. One typed without https:// comes back with it added.

**Example output**

```json
{
  "final_url": "https://example.com",
  "headers": {
    "accept-ranges": "bytes",
    "age": "8078",
    "allow": "GET, HEAD",
    "alt-svc": "h3=\":443\"; ma=86400",
    "cf-cache-status": "HIT",
    "cf-ray": "a4b2da3b5ea39ed7-CDG",
    "content-type": "text/html; charset=utf-8",
    "date": "Fri, 16 Oct 2026 00:12:31 GMT",
    "last-modified": "Tue, 13 Oct 2026 20:08:28 GMT",
    "server": "cloudflare"
  },
  "redirects": [],
  "status_code": 200,
  "status_text": "OK",
  "url": "https://example.com"
}
```

### Look up a domain's IP addresses

Find the IP addresses a domain points at, both IPv4 and IPv6, such as to check a site has moved to a new server or to allow it through a firewall. No account or API key required.

**Inputs**

- Domain (`domain`, text, required): The domain to look up, such as wikipedia.org. A whole link works too, and is cut down to its domain.

**Outputs**

- `domain` (text): The domain that was looked up, e.g. wikipedia.org, taken from whatever was typed: a whole link comes down to its domain.
- `found` (true/false): Whether the domain points anywhere. False for a domain that doesn't exist or has no addresses.
- `ip_addresses` (list): Every address, IPv4 ones first.
- `ipv4` (list): The IPv4 addresses, e.g. 185.15.58.224.
- `ipv6` (list): The IPv6 addresses, e.g. 2a02:ec80:600:ed1a::1.

**Example output**

```json
{
  "domain": "wikipedia.org",
  "found": true,
  "ip_addresses": [
    "185.15.58.224",
    "2a02:ec80:600:ed1a::1"
  ],
  "ipv4": [
    "185.15.58.224"
  ],
  "ipv6": [
    "2a02:ec80:600:ed1a::1"
  ]
}
```

### Look up an IP address's provider

Find the internet provider or hosting company behind an IP address, such as one from a sign-up form or a server log, or behind a website's domain. No account or API key required.

**Inputs**

- IP address or domain (`address`, text, required): The IP address to look up, IPv4 or IPv6, or a domain or link, whose address is looked up for you.

**Outputs**

- `address` (text): The IP address or domain that was looked up.
- `found` (true/false): Whether a provider was found.
- `isp` (text): The provider's name, e.g. Google LLC. Null when no provider is on record.
- `network_handle` (text): The provider's short code in the address registry, e.g. GOGL, when the record gives one; otherwise null.

**Example output**

```json
{
  "address": "8.8.8.8",
  "found": true,
  "isp": "Google LLC",
  "network_handle": "GOGL"
}
```

### Look up DNS records

List a domain's DNS records: its addresses, mail servers, name servers and text records such as SPF and site verification. Pick one kind to check a single setting, such as whether the mail servers have changed. No account or API key required.

**Inputs**

- Domain (`domain`, text, required): The domain to look up, such as wikipedia.org. A whole link works too, and is cut down to its domain.
- Record type (`record_type`, text): Which records to return, or all of them. One of: `all` (All records), `A` (A: IPv4 addresses), `AAAA` (AAAA: IPv6 addresses), `CNAME` (CNAME: another name it points to), `MX` (MX: mail servers), `NS` (NS: name servers), `TXT` (TXT: text, such as SPF and site verification). Default: `all`.

**Outputs**

- `count` (number): How many records are in the list.
- `domain` (text): The domain that was looked up, e.g. wikipedia.org, taken from whatever was typed: a whole link comes down to its domain.
- `found` (true/false): Whether the domain has any records at all, of any kind. False for a domain that doesn't exist.
- `record_type` (text): The kind of record asked for: all, A, AAAA, CNAME, MX, NS or TXT.
- `records` (list): The records, in the order DNS gave them.

**Example output**

```json
{
  "count": 8,
  "domain": "example.com",
  "found": true,
  "record_type": "all",
  "records": [
    {
      "name": "example.com",
      "priority": null,
      "ttl": 244,
      "type": "A",
      "value": "104.20.23.154"
    },
    {
      "name": "example.com",
      "priority": null,
      "ttl": 244,
      "type": "A",
      "value": "172.66.147.243"
    },
    {
      "name": "example.com",
      "priority": null,
      "ttl": 7078,
      "type": "NS",
      "value": "elliott.ns.cloudflare.com"
    },
    {
      "name": "example.com",
      "priority": null,
      "ttl": 7078,
      "type": "NS",
      "value": "hera.ns.cloudflare.com"
    },
    {
      "name": "example.com",
      "priority": null,
      "ttl": 300,
      "type": "TXT",
      "value": "v=spf1 -all"
    },
    {
      "name": "example.com",
      "priority": null,
      "ttl": 300,
      "type": "TXT",
      "value": "_k2n1y4vw3qtb4skdx9e7dxt97qrmmq9"
    },
    {
      "name": "example.com",
      "priority": null,
      "ttl": 110,
      "type": "AAAA",
      "value": "2606:4700:10::6814:179a"
    },
    {
      "name": "example.com",
      "priority": null,
      "ttl": 110,
      "type": "AAAA",
      "value": "2606:4700:10::ac42:93f3"
    }
  ]
}
```

### Look up who owns a domain

Read a domain's public ownership record (whois): who holds it where they choose to say, the company it is registered through, when it was registered and when it expires, with the days left to branch on. Also says whether a domain is still free to register. No account or API key required.

**Inputs**

- Domain (`domain`, text, required): The domain to look up, such as wikipedia.org. A whole link works too, and so does a site on the domain, such as en.wikipedia.org: the record is the registered domain's. An IP address gives the record of the network it belongs to.

**Outputs**

- `created_on` (text): When the domain was first registered, as a date (2001-01-13). Null when the record doesn't say.
- `days_until_expiry` (number): How many days are left until the expiry date, for a reminder to renew. Null when there is no date.
- `domain` (text): The domain whose record this is: the registered domain, so en.wikipedia.org comes back as wikipedia.org.
- `expires_on` (text): When the registration runs out unless renewed, as a date. Null when the record doesn't say, as some countries' records don't.
- `name_servers` (list): The servers that answer for the domain.
- `owner` (text): The organisation that holds the domain, when it chooses to publish it. Many owners keep it private, and then this is null.
- `owner_country` (text): The owner's country as a two letter code, e.g. US. Null when the record doesn't say.
- `raw` (text): The whole record as the registry wrote it, for anything the fields above leave out.
- `registered` (true/false): Whether somebody holds the domain. False means it is free to register.
- `registrar` (text): The company the domain is registered through, e.g. MarkMonitor, Inc. Null when the record doesn't say.
- `statuses` (list): The registration's status flags, e.g. clientTransferProhibited, which locks it against being moved to another registrar.
- `updated_on` (text): When the record last changed, as a date. Null when the record doesn't say.

**Example output**

```json
{
  "created_on": "2001-01-13",
  "days_until_expiry": 89,
  "domain": "wikipedia.org",
  "expires_on": "2027-01-13",
  "name_servers": [
    "ns2.wikimedia.org",
    "ns1.wikimedia.org",
    "ns0.wikimedia.org"
  ],
  "owner": "Wikimedia Foundation, Inc.",
  "owner_country": "US",
  "raw": "Domain Name: wikipedia.org\nRegistry Domain ID: D51687756-LROR\nRegistrar WHOIS Server: whois.markmonitor.com\nRegistrar URL: http://www.markmonitor.com\nUpdated Date: 2025-12-12T09:26:03+0000\nCreation Date: 2001-01-13T00:12:14+0000\nRegistrar Registration Expiration Date: 2027-01-13T00:00:00+0000\nRegistrar: MarkMonitor, Inc.",
  "registered": true,
  "registrar": "MarkMonitor, Inc.",
  "statuses": [
    "clientUpdateProhibited",
    "clientTransferProhibited",
    "clientDeleteProhibited"
  ],
  "updated_on": "2025-12-12"
}
```

### Shorten a link

Turn a long web address into a short da.gd link to paste into a text message, a post or anywhere else the whole address would not fit, optionally with an ending of your choosing. The same link always gives the same short link, so a workflow that runs again reuses the one it made. No account or API key required.

**Inputs**

- Link (`url`, text, required): The web address to shorten. Paste it exactly as it appears in the address bar: question marks, ampersands and tracking parameters are all fine, and an address typed without https:// gets it added.
- Custom ending (`custom_ending`, text): What the short link ends with instead of a random code, such as spring-26 for da.gd/spring-26: up to 10 letters, numbers, hyphens and underscores, where capitals count. Leave it blank for a random ending. An ending that is taken can't be had, unless it already opens this same link, as it does when the step runs again.

**Outputs**

- `code` (text): The end of the short link, after da.gd/, e.g. LMbIp. Capitals count.
- `original_url` (text): The long link. An address typed without https:// comes back with it added, so this is exactly what the short link opens.
- `short_url` (text): The short link, e.g. https://da.gd/LMbIp. Paste this wherever the long one would have gone.

**Example output**

```json
{
  "code": "LMbIp",
  "original_url": "https://en.wikipedia.org/wiki/URL_shortening",
  "short_url": "https://da.gd/LMbIp"
}
```