# SRV Record Parser API Documentation

> Complete SRV Record Parser API documentation with examples, parameters, authentication, and code samples. SRV Record Parser analyzes DNS SRV records and extracts service location information including priority, weight, port, and target server details. Fast, reliable, and easy to integrate.

# ![SRV Record Parser](https://apiverve.web.app/publicapis/logos/srvparser.svg)SRV Record Parser

OnlineToken Usage:1 per callLatency:241ms avg

SRV Record Parser analyzes DNS SRV records and extracts service location information including priority, weight, port, and target server details.

This API provides reliable and fast access to srv record parser data through a simple REST interface. Built for developers who need consistent, high-quality results with minimal setup time.

To use this API, you need an API key. You can get one by [creating a free account](https://apiverve.com/signup) and visiting your [dashboard](https://apiverve.com/dashboard).

[View API in Directory](https://apiverve.com/marketplace/srvparser)

## POST Endpoint

URL

```http
https://api.apiverve.com/v1/srvparser
```

## Code Examples

Here are examples of how to call this API in different programming languages:

cURLJavaScriptPythonNode.jsPHPGoRubyC#

cURL Request

```bash
curl -X POST \
  "https://api.apiverve.com/v1/srvparser" \
  -H "X-API-Key: your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "record": "_http._tcp.example.com. 86400 IN SRV 10 60 80 server.example.com."
}'
```

JavaScript (Fetch API)

```javascript
const response = await fetch('https://api.apiverve.com/v1/srvparser', {
  method: 'POST',
  headers: {
    'X-API-Key': 'your_api_key_here',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "record": "_http._tcp.example.com. 86400 IN SRV 10 60 80 server.example.com."
})
});

const data = await response.json();
console.log(data);
```

Python (Requests)

```python
import requests

headers = {
    'X-API-Key': 'your_api_key_here',
    'Content-Type': 'application/json'
}

payload = {
    "record": "_http._tcp.example.com. 86400 IN SRV 10 60 80 server.example.com."
}

response = requests.post('https://api.apiverve.com/v1/srvparser', headers=headers, json=payload)

data = response.json()
print(data)
```

Node.js (Native HTTPS)

```javascript
const https = require('https');
const url = require('url');

const options = {
  method: 'POST',
  headers: {
    'X-API-Key': 'your_api_key_here',
    'Content-Type': 'application/json'
  }
};

const postData = JSON.stringify({
  "record": "_http._tcp.example.com. 86400 IN SRV 10 60 80 server.example.com."
});

const req = https.request('https://api.apiverve.com/v1/srvparser', options, (res) => {
  let data = '';
  res.on('data', (chunk) => data += chunk);
  res.on('end', () => console.log(JSON.parse(data)));
});

req.write(postData);
req.end();
```

PHP (cURL)

```php
<?php

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://api.apiverve.com/v1/srvparser');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'X-API-Key: your_api_key_here',
    'Content-Type: application/json'
]);

curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode({
    'record': '_http._tcp.example.com. 86400 IN SRV 10 60 80 server.example.com.'
}));

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

?>
```

Go (net/http)

```go
package main

import (
    "fmt"
    "io"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    payload := map[string]interface{}{
        "record": "_http._tcp.example.com. 86400 IN SRV 10 60 80 server.example.com."
    }

    jsonPayload, _ := json.Marshal(payload)
    req, _ := http.NewRequest("POST", "https://api.apiverve.com/v1/srvparser", bytes.NewBuffer(jsonPayload))

    req.Header.Set("X-API-Key", "your_api_key_here")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}
```

Ruby (Net::HTTP)

```ruby
require 'net/http'
require 'json'

uri = URI('https://api.apiverve.com/v1/srvparser')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

payload = {
  "record": "_http._tcp.example.com. 86400 IN SRV 10 60 80 server.example.com."
}

request = Net::HTTP::Post.new(uri)
request['X-API-Key'] = 'your_api_key_here'
request['Content-Type'] = 'application/json'

request.body = payload.to_json

response = http.request(request)
puts JSON.pretty_generate(JSON.parse(response.body))
```

C# (HttpClient)

```csharp
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("X-API-Key", "your_api_key_here");

        var jsonContent = @"{
        ""record"": ""_http._tcp.example.com. 86400 IN SRV 10 60 80 server.example.com.""
}";
        var content = new StringContent(jsonContent, Encoding.UTF8, "application/json");

        var response = await client.PostAsync("https://api.apiverve.com/v1/srvparser", content);
        response.EnsureSuccessStatusCode();

        var responseBody = await response.Content.ReadAsStringAsync();
        Console.WriteLine(responseBody);
    }
}
```

## Authentication

This API requires authentication via API key. Include your API key in the request header:

Required Header

```
X-API-Key: your_api_key_here
```

## Interactive API Playground

Test this API directly in your browser with live requests and responses.

[

**Open in API Playground**Test with your API key in the dashboard

](https://dashboard.apiverve.com/playground?id=srvparser)

## Parameters

The following parameters are available for this API endpoint:

Parameter

Type

Required

Description

Default

Example

record

string

Yes

The SRV record string to parse

\-

\_http.\_tcp.example.com. 3600 IN SRV 10 60 80 server.example.com.

## Response

The API returns responses in JSON, XML, YAML, Markdown, and CSV formats:

### Example Responses

JSONXMLYAMLMarkdownCSV

JSON Response

200 OK

```json
{
  "status": "ok",
  "error": null,
  "data": {
    "raw_record": "_http._tcp.example.com. 86400 IN SRV 10 60 80 server.example.com.",
    "parsed": {
      "name": "_http._tcp.example.com.",
      "service": "_http",
      "protocol": "tcp",
      "domain": "example.com.",
      "ttl": 86400,
      "class": "IN",
      "priority": 10,
      "weight": 60,
      "port": 80,
      "target": "server.example.com"
    },
    "service_info": {
      "name": "HTTP",
      "description": "Web service",
      "default_port": 80
    },
    "interpretation": {
      "priority_explanation": "Priority level 10 (lower is better)",
      "weight_explanation": "Weight 60 for load balancing",
      "target_explanation": "Connect to server.example.com:80"
    },
    "is_valid": true
  }
}
```

XML Response

200 OK

```xml
<Root>
  <status>ok</status>
  <error />
  <data>
    <raw_record>_http._tcp.example.com. 86400 IN SRV 10 60 80 server.example.com.</raw_record>
    <parsed>
      <name>_http._tcp.example.com.</name>
      <service>_http</service>
      <protocol>tcp</protocol>
      <domain>example.com.</domain>
      <ttl>86400</ttl>
      <class>IN</class>
      <priority>10</priority>
      <weight>60</weight>
      <port>80</port>
      <target>server.example.com</target>
    </parsed>
    <service_info>
      <name>HTTP</name>
      <description>Web service</description>
      <default_port>80</default_port>
    </service_info>
    <interpretation>
      <priority_explanation>Priority level 10 (lower is better)</priority_explanation>
      <weight_explanation>Weight 60 for load balancing</weight_explanation>
      <target_explanation>Connect to server.example.com:80</target_explanation>
    </interpretation>
    <is_valid>true</is_valid>
  </data>
</Root>
```

YAML Response

200 OK

```yaml
status: ok
error: 
data:
  raw_record: _http._tcp.example.com. 86400 IN SRV 10 60 80 server.example.com.
  parsed:
    name: _http._tcp.example.com.
    service: _http
    protocol: tcp
    domain: example.com.
    ttl: 86400
    class: IN
    priority: 10
    weight: 60
    port: 80
    target: server.example.com
  service_info:
    name: HTTP
    description: Web service
    default_port: 80
  interpretation:
    priority_explanation: Priority level 10 (lower is better)
    weight_explanation: Weight 60 for load balancing
    target_explanation: Connect to server.example.com:80
  is_valid: true
```

Markdown Response

200 OK

```markdown
| Field | Value |
| --- | --- |
| status | ok |
| error |  |
| raw_record | _http._tcp.example.com. 86400 IN SRV 10 60 80 server.example.com. |
| parsed.name | _http._tcp.example.com. |
| parsed.service | _http |
| parsed.protocol | tcp |
| parsed.domain | example.com. |
| parsed.ttl | 86400 |
| parsed.class | IN |
| parsed.priority | 10 |
| parsed.weight | 60 |
| parsed.port | 80 |
| parsed.target | server.example.com |
| service_info.name | HTTP |
| service_info.description | Web service |
| service_info.default_port | 80 |
| interpretation.priority_explanation | Priority level 10 (lower is better) |
| interpretation.weight_explanation | Weight 60 for load balancing |
| interpretation.target_explanation | Connect to server.example.com:80 |
| is_valid | True |
```

CSV Response

200 OK

status

error

raw\_record

parsed.name

parsed.service

parsed.protocol

parsed.domain

parsed.ttl

parsed.class

parsed.priority

parsed.weight

parsed.port

parsed.target

service\_info.name

service\_info.description

service\_info.default\_port

interpretation.priority\_explanation

interpretation.weight\_explanation

interpretation.target\_explanation

is\_valid

ok

\_http.\_tcp.example.com. 86400 IN SRV 10 60 80 server.example.com.

\_http.\_tcp.example.com.

\_http

tcp

example.com.

86400

IN

10

60

80

server.example.com

HTTP

Web service

80

Priority level 10 (lower is better)

Weight 60 for load balancing

Connect to server.example.com:80

True

[Live Test API in Playground](https://dashboard.apiverve.com/playground?api=srvparser)

### Response Structure

All API responses follow a consistent structure with the following fields:

Field

Type

Description

Example

status

string

Indicates whether the request was successful ("ok") or failed ("error")

ok

error

string | null

Contains error message if status is "error", otherwise null

null

data

object | null

Contains the API response data if successful, otherwise null

{...}

### Response Data Fields

When the request is successful, the `data` object contains the following fields:

Field

Type

Sample Value

raw\_record

string

"\_http.\_tcp.example.com. 86400 IN SRV 10 60 80 server.example.com."

parsed

object

{...}

└ name

string

"\_http.\_tcp.example.com."

└ service

string

"\_http"

└ protocol

string

"tcp"

└ domain

string

"example.com."

└ ttl

number

86400

└ class

string

"IN"

└ priority

number

10

└ weight

number

60

└ port

number

80

└ target

string

"server.example.com"

service\_info

object

{...}

└ name

string

"HTTP"

└ description

string

"Web service"

└ default\_port

number

80

interpretation

object

{...}

└ priority\_explanation

string

"Priority level 10 (lower is better)"

└ weight\_explanation

string

"Weight 60 for load balancing"

└ target\_explanation

string

"Connect to server.example.com:80"

## Headers

Required and optional headers for API requests:

Header Name

Required

Example Value

Description

X-API-Key

Yes

your\_api\_key\_here

Your APIVerve API key. Found in your dashboard under API Keys.

Accept

No

application/json

Specify response format: application/json (default), application/xml, or application/yaml

User-Agent

No

MyApp/1.0

Identifies your application for analytics and debugging purposes

X-Request-ID

No

req\_123456789

Custom request identifier for tracking and debugging requests

Cache-Control

No

no-cache

Control caching behavior for the request and response

## GraphQL AccessALPHA

Most APIVerve APIs support GraphQL queries, allowing you to combine multiple API calls into a single request and retrieve only the data you need. This powerful feature enables you to orchestrate complex data fetching with precise field selection.

Not all APIs support GraphQL. Check the API schema or test in the GraphQL Explorer to confirm availability for this specific endpoint.

**Token Cost:** Each API called in your GraphQL query consumes its standard token cost.

GraphQL Endpoint

```http
POST https://api.apiverve.com/v1/graphql
```

GraphQL Query Example

```graphql
query {
  srvparser(
    input: {
      record: "_http._tcp.example.com. 86400 IN SRV 10 60 80 server.example.com."
    }
  ) {
    raw_record
    parsed {
      name
      service
      protocol
      domain
      ttl
      class
      priority
      weight
      port
      target
    }
    service_info {
      name
      description
      default_port
    }
    interpretation {
      priority_explanation
      weight_explanation
      target_explanation
    }
    is_valid
  }
}
```

**Note:** Authentication is handled via the `x-api-key` header in your GraphQL request, not as a query parameter.

[Try in GraphQL Explorer](https://dashboard.apiverve.com/vervekit/graphql)[GraphQL Documentation](/graphql/usage)

## CORS Support

All APIVerve APIs support Cross-Origin Resource Sharing (CORS) with wildcard configuration, allowing you to call the API directly from browser-based applications without proxy servers.

CORS Header

Value

Description

Access-Control-Allow-Origin

\*

Accepts requests from any origin

Access-Control-Allow-Methods

\*

Accepts any HTTP method

Access-Control-Allow-Headers

\*

Accepts any request headers

**Browser Usage:** You can make direct API calls from JavaScript running in the browser without encountering CORS errors. No additional configuration needed.

## Rate Limiting

APIVerve implements rate limiting to ensure fair usage and maintain service quality across all users. Rate limits vary by subscription plan and are applied per API key.

Plan

Rate Limit

Description

Free

5 requests/min

Hard rate limit enforced - exceeding will return 429 errors

Starter

No Limit

Production ready - no rate limiting or throttling

Pro

No Limit

Production ready - no rate limiting or throttling

Mega

No Limit

Production ready - no rate limiting or throttling

### Rate Limit Headers

When rate limits apply, each API response includes headers to help you track your usage:

Header

Description

X-RateLimit-Limit

Maximum number of requests allowed per time window

X-RateLimit-Remaining

Number of requests remaining in the current window

X-RateLimit-Reset

Unix timestamp when the rate limit window resets

### Handling Rate Limits

**Free Plan:** When you exceed your rate limit, the API returns a `429 Too Many Requests` status code. Your application should implement appropriate backoff logic to handle this gracefully.

**Paid Plans:** No rate limiting or throttling applied. All paid plans (Starter, Pro, Mega) are production-ready.

**Best Practices:**

-   Monitor the rate limit headers to track your usage (Free plan only)
-   Implement caching where appropriate to reduce API calls
-   Upgrade to Pro or Mega for guaranteed no-throttle performance

**Note:** Rate limits are separate from token consumption. You may have tokens remaining but still hit rate limits on Free tier.

## Client Libraries

To get started with minimal code, most of our APIs are available through client libraries and clients:

[![NPM](/images/npm.png)](https://www.npmjs.com/~apivervehq)[![PyPI](/images/pypi.png)](https://pypi.org/user/apiverve/)[![NuGet](/images/nuget.png)](http://nuget.org/profiles/APIVerve)[![Swagger](/images/swagger.png)](https://apiverve.web.app/publicapis/api-schema/srvparser.json)

## Error Codes

The API uses standard HTTP status codes to indicate success or failure:

Code

Message

Description

Solution

200

OK

Request successful, data returned

No action needed - request was successful

400

Bad Request

Invalid request parameters or malformed request

Check required parameters and ensure values match expected formats

401

Unauthorized

Missing or invalid API key

Include x-api-key header with valid API key from dashboard

403

Forbidden

API key lacks permission or insufficient tokens

Check token balance in dashboard or upgrade plan

429

Too Many Requests

Rate limit exceeded (Free: 5 req/min)

Implement request throttling or upgrade to paid plan

500

Internal Server Error

Server error occurred

Retry request after a few seconds, contact support if persists

503

Service Unavailable

API temporarily unavailable

Wait and retry, check status page for maintenance updates

**Need help?** [Contact support](https://apiverve.com/contact) with your `X-Request-ID` for assistance.

## Frequently Asked Questions

How do I get an API key?

Sign up for a free account at [dashboard.apiverve.com](https://dashboard.apiverve.com). Your API key will be automatically generated and available in your dashboard. The free plan includes 1,000 tokens plus a 500 token bonus.

What are tokens and how do they work?

Tokens are your API usage currency. Each successful API call consumes tokens based on the API's complexity. Most APIs cost 1 token per call, while more complex APIs may cost 2-5 tokens. Failed requests and errors don't consume tokens. Check the API details above to see the token cost for this specific API.

Can I use this API in production?

The free plan is for testing and development only. For production use, upgrade to a paid plan (Starter, Pro, or Mega) which includes commercial use rights, no attribution requirements, and guaranteed uptime SLAs. All paid plans are production-ready.

Can I use this API from a browser?

Yes! All APIVerve APIs support CORS with wildcard configuration, so you can call them directly from browser-based JavaScript without needing a proxy server. See the [CORS section](#cors) above for details.

What happens if I exceed my token limit?

When you reach your monthly token limit, API requests will return an error until you upgrade your plan or wait for the next billing cycle. You'll receive notifications at 80% and 95% usage to give you time to upgrade if needed.

## People who used this also used...

Based on your interest in SRV Record Parser, you might also like these APIs:

[

![Birthstones](https://apiverve.web.app/publicapis/logos/birthstones.svg)

### Birthstones

Birthstones is a comprehensive lookup API for birthstone information. It returns detailed data about gemstones associated with each birth month, including the primary stone, alternate stones, colors, meanings, and zodiac associations.

1 token per call

](/ref/birthstones)[

![Mayan Calendar](https://apiverve.web.app/publicapis/logos/mayancalendar.svg)

### Mayan Calendar

Mayan Calendar converts Gregorian dates to the ancient Mayan calendar system. Returns the Long Count, Tzolkin (260-day sacred calendar), and Haab (365-day civil calendar) dates.

1 token per call

](/ref/mayancalendar)[

![Shoe Size Converter](https://apiverve.web.app/publicapis/logos/shoesizeconverter.svg)

### Shoe Size Converter

Shoe Size Converter is a tool for converting shoe sizes between US, UK, EU, CM, JP, AU, MX, and KR standards. It supports men, women, unisex, and child sizes.

1 token per call

](/ref/shoesizeconverter)

## What's Next?

Continue your journey with these recommended resources

[

### Browse All APIs

Explore our complete catalog of APIs

](/api-endpoints)[

### Authentication Guide

Learn about API keys and security

](/authentication)[

### Rate Limits

Understand usage limits and best practices

](/rate-limits)

Help us improve our documentation

YesNo

Copy for LLM[View as Markdown](/ref/srvparser/ai.md "View this page as plain markdown")[Star](https://github.com/apiverve/srvparser-api "Star srvparser API on GitHub")

---

*Source: [docs.apiverve.com/ref/srvparser](https://docs.apiverve.com/ref/srvparser)*