diff --git a/app/models.py b/app/models.py
index 9b3ab9b..e077208 100644
--- a/app/models.py
+++ b/app/models.py
@@ -31,17 +31,6 @@ if 'PRETTY_IPV6_PTR' in app.config.keys():
 else:
     PRETTY_IPV6_PTR = False
 
-PDNS_STATS_URL = app.config['PDNS_STATS_URL']
-PDNS_API_KEY = app.config['PDNS_API_KEY']
-PDNS_VERSION = app.config['PDNS_VERSION']
-API_EXTENDED_URL = utils.pdns_api_extended_uri(PDNS_VERSION)
-
-# Flag for pdns v4.x.x
-# TODO: Find another way to do this
-if StrictVersion(PDNS_VERSION) >= StrictVersion('4.0.0'):
-    NEW_SCHEMA = True
-else:
-    NEW_SCHEMA = False
 
 class Anonymous(AnonymousUserMixin):
   def __init__(self):
@@ -733,6 +722,16 @@ class Domain(db.Model):
         self.last_check = last_check
         self.dnssec = dnssec
         self.account_id = account_id
+        # PDNS configs
+        self.PDNS_STATS_URL = Setting().get('pdns_api_url')
+        self.PDNS_API_KEY = Setting().get('pdns_api_key')
+        self.PDNS_VERSION = Setting().get('pdns_version')
+        self.API_EXTENDED_URL = utils.pdns_api_extended_uri(self.PDNS_VERSION)
+
+        if StrictVersion(self.PDNS_VERSION) >= StrictVersion('4.0.0'):
+            self.NEW_SCHEMA = True
+        else:
+            self.NEW_SCHEMA = False
 
     def __repr__(self):
         return '<Domain {0}>'.format(self.name)
@@ -751,8 +750,8 @@ class Domain(db.Model):
         Get all domains which has in PowerDNS
         """
         headers = {}
-        headers['X-API-Key'] = PDNS_API_KEY
-        jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain_name)), headers=headers)
+        headers['X-API-Key'] = self.PDNS_API_KEY
+        jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain_name)), headers=headers)
         return jdata
 
     def get_domains(self):
@@ -760,8 +759,8 @@ class Domain(db.Model):
         Get all domains which has in PowerDNS
         """
         headers = {}
-        headers['X-API-Key'] = PDNS_API_KEY
-        jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones'), headers=headers)
+        headers['X-API-Key'] = self.PDNS_API_KEY
+        jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones'), headers=headers)
         return jdata
 
     def get_id_by_name(self, name):
@@ -783,9 +782,9 @@ class Domain(db.Model):
         dict_db_domain = dict((x.name,x) for x in db_domain)
 
         headers = {}
-        headers['X-API-Key'] = PDNS_API_KEY
+        headers['X-API-Key'] = self.PDNS_API_KEY
         try:
-            jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones'), headers=headers)
+            jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones'), headers=headers)
             list_jdomain = [d['name'].rstrip('.') for d in jdata]
             try:
                 # domains should remove from db since it doesn't exist in powerdns anymore
@@ -866,9 +865,9 @@ class Domain(db.Model):
         Add a domain to power dns
         """
         headers = {}
-        headers['X-API-Key'] = PDNS_API_KEY
+        headers['X-API-Key'] = self.PDNS_API_KEY
 
-        if NEW_SCHEMA:
+        if self.NEW_SCHEMA:
             domain_name = domain_name + '.'
             domain_ns = [ns + '.' for ns in domain_ns]
 
@@ -888,7 +887,7 @@ class Domain(db.Model):
         }
 
         try:
-            jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones'), headers=headers, method='POST', data=post_data)
+            jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones'), headers=headers, method='POST', data=post_data)
             if 'error' in jdata.keys():
                 logging.error(jdata['error'])
                 return {'status': 'error', 'msg': jdata['error']}
@@ -906,7 +905,7 @@ class Domain(db.Model):
         if not domain:
             return {'status': 'error', 'msg': 'Domain doesnt exist.'}
         headers = {}
-        headers['X-API-Key'] = PDNS_API_KEY
+        headers['X-API-Key'] = self.PDNS_API_KEY
 
         if soa_edit_api not in ["DEFAULT", "INCREASE", "EPOCH", "OFF"]:
             soa_edit_api = 'DEFAULT'
@@ -921,7 +920,7 @@ class Domain(db.Model):
 
         try:
             jdata = utils.fetch_json(
-            urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain.name)), headers=headers,
+            urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain.name)), headers=headers,
             method='PUT', data=post_data)
             if 'error' in jdata.keys():
                 logging.error(jdata['error'])
@@ -994,9 +993,9 @@ class Domain(db.Model):
         Delete a single domain name from powerdns
         """
         headers = {}
-        headers['X-API-Key'] = PDNS_API_KEY
+        headers['X-API-Key'] = self.PDNS_API_KEY
         try:
-            jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain_name)), headers=headers, method='DELETE')
+            jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain_name)), headers=headers, method='DELETE')
             logging.info('Delete domain {0} successfully'.format(domain_name))
             return {'status': 'ok', 'msg': 'Delete domain successfully'}
         except Exception as e:
@@ -1051,9 +1050,9 @@ class Domain(db.Model):
         domain = Domain.query.filter(Domain.name == domain_name).first()
         if domain:
             headers = {}
-            headers['X-API-Key'] = PDNS_API_KEY
+            headers['X-API-Key'] = self.PDNS_API_KEY
             try:
-                jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}/axfr-retrieve'.format(domain.name)), headers=headers, method='PUT')
+                jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}/axfr-retrieve'.format(domain.name)), headers=headers, method='PUT')
                 return {'status': 'ok', 'msg': 'Update from Master successfully'}
             except:
                 return {'status': 'error', 'msg': 'There was something wrong, please contact administrator'}
@@ -1067,9 +1066,9 @@ class Domain(db.Model):
         domain = Domain.query.filter(Domain.name == domain_name).first()
         if domain:
             headers = {}
-            headers['X-API-Key'] = PDNS_API_KEY
+            headers['X-API-Key'] = self.PDNS_API_KEY
             try:
-                jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}/cryptokeys'.format(domain.name)), headers=headers, method='GET')
+                jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}/cryptokeys'.format(domain.name)), headers=headers, method='GET')
                 if 'error' in jdata:
                     return {'status': 'error', 'msg': 'DNSSEC is not enabled for this domain'}
                 else:
@@ -1086,13 +1085,13 @@ class Domain(db.Model):
         domain = Domain.query.filter(Domain.name == domain_name).first()
         if domain:
             headers = {}
-            headers['X-API-Key'] = PDNS_API_KEY
+            headers['X-API-Key'] = self.PDNS_API_KEY
             try:
                 # Enable API-RECTIFY for domain, BEFORE activating DNSSEC
                 post_data = {
                     "api_rectify": True
                 }
-                jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain.name)), headers=headers, method='PUT', data=post_data)
+                jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain.name)), headers=headers, method='PUT', data=post_data)
                 if 'error' in jdata:
                     return {'status': 'error', 'msg': 'API-RECTIFY could not be enabled for this domain', 'jdata' : jdata}
 
@@ -1101,7 +1100,7 @@ class Domain(db.Model):
                     "keytype": "ksk",
                     "active": True
                 }
-                jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}/cryptokeys'.format(domain.name)), headers=headers, method='POST',data=post_data)
+                jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}/cryptokeys'.format(domain.name)), headers=headers, method='POST',data=post_data)
                 if 'error' in jdata:
                     return {'status': 'error', 'msg': 'Cannot enable DNSSEC for this domain. Error: {0}'.format(jdata['error']), 'jdata' : jdata}
 
@@ -1121,10 +1120,10 @@ class Domain(db.Model):
         domain = Domain.query.filter(Domain.name == domain_name).first()
         if domain:
             headers = {}
-            headers['X-API-Key'] = PDNS_API_KEY
+            headers['X-API-Key'] = self.PDNS_API_KEY
             try:
                 # Deactivate DNSSEC
-                jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}/cryptokeys/{1}'.format(domain.name, key_id)), headers=headers, method='DELETE')
+                jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}/cryptokeys/{1}'.format(domain.name, key_id)), headers=headers, method='DELETE')
                 if jdata != True:
                     return {'status': 'error', 'msg': 'Cannot disable DNSSEC for this domain. Error: {0}'.format(jdata['error']), 'jdata' : jdata}
 
@@ -1132,7 +1131,7 @@ class Domain(db.Model):
                 post_data = {
                     "api_rectify": False
                 }
-                jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain.name)), headers=headers, method='PUT', data=post_data)
+                jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain.name)), headers=headers, method='PUT', data=post_data)
                 if 'error' in jdata:
                     return {'status': 'error', 'msg': 'API-RECTIFY could not be disabled for this domain', 'jdata' : jdata}
 
@@ -1161,7 +1160,7 @@ class Domain(db.Model):
             return {'status': False, 'msg': 'Domain does not exist'}
 
         headers = {}
-        headers['X-API-Key'] = PDNS_API_KEY
+        headers['X-API-Key'] = self.PDNS_API_KEY
 
         account_name = Account().get_name_by_id(account_id)
 
@@ -1171,7 +1170,7 @@ class Domain(db.Model):
 
         try:
             jdata = utils.fetch_json(
-            urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain_name)), headers=headers,
+            urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain_name)), headers=headers,
             method='PUT', data=post_data)
 
             if 'error' in jdata.keys():
@@ -1240,20 +1239,30 @@ class Record(object):
         self.status = status
         self.ttl = ttl
         self.data = data
+        # PDNS configs
+        self.PDNS_STATS_URL = Setting().get('pdns_api_url')
+        self.PDNS_API_KEY = Setting().get('pdns_api_key')
+        self.PDNS_VERSION = Setting().get('pdns_version')
+        self.API_EXTENDED_URL = utils.pdns_api_extended_uri(self.PDNS_VERSION)
+
+        if StrictVersion(self.PDNS_VERSION) >= StrictVersion('4.0.0'):
+            self.NEW_SCHEMA = True
+        else:
+            self.NEW_SCHEMA = False
 
     def get_record_data(self, domain):
         """
         Query domain's DNS records via API
         """
         headers = {}
-        headers['X-API-Key'] = PDNS_API_KEY
+        headers['X-API-Key'] = self.PDNS_API_KEY
         try:
-            jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain)), headers=headers)
+            jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain)), headers=headers)
         except:
             logging.error("Cannot fetch domain's record data from remote powerdns api")
             return False
 
-        if NEW_SCHEMA:
+        if self.NEW_SCHEMA:
             rrsets = jdata['rrsets']
             for rrset in rrsets:
                 r_name = rrset['name'].rstrip('.')
@@ -1284,9 +1293,9 @@ class Record(object):
 
         # continue if the record is ready to be added
         headers = {}
-        headers['X-API-Key'] = PDNS_API_KEY
+        headers['X-API-Key'] = self.PDNS_API_KEY
 
-        if NEW_SCHEMA:
+        if self.NEW_SCHEMA:
             data = {"rrsets": [
                         {
                             "name": self.name.rstrip('.') + '.',
@@ -1322,7 +1331,7 @@ class Record(object):
                 }
 
         try:
-            jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain)), headers=headers, method='PATCH', data=data)
+            jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain)), headers=headers, method='PATCH', data=data)
             logging.debug(jdata)
             return {'status': 'ok', 'msg': 'Record was added successfully'}
         except Exception as e:
@@ -1363,7 +1372,7 @@ class Record(object):
             r_name = domain if r['record_name'] in ['@', ''] else r['record_name'] + '.' + domain
             r_type = r['record_type']
             if PRETTY_IPV6_PTR: # only if activated
-                if NEW_SCHEMA: # only if new schema
+                if self.NEW_SCHEMA: # only if new schema
                     if r_type == 'PTR': # only ptr
                         if ':' in r['record_name']: # dirty ipv6 check
                             r_name = r['record_name']
@@ -1381,10 +1390,10 @@ class Record(object):
 
         records = []
         for r in deleted_records:
-            r_name = r['name'].rstrip('.') + '.' if NEW_SCHEMA else r['name']
+            r_name = r['name'].rstrip('.') + '.' if self.NEW_SCHEMA else r['name']
             r_type = r['type']
             if PRETTY_IPV6_PTR: # only if activated
-                if NEW_SCHEMA: # only if new schema
+                if self.NEW_SCHEMA: # only if new schema
                     if r_type == 'PTR': # only ptr
                         if ':' in r['name']: # dirty ipv6 check
                             r_name = dns.reversename.from_address(r['name']).to_text()
@@ -1402,7 +1411,7 @@ class Record(object):
 
         records = []
         for r in new_records:
-            if NEW_SCHEMA:
+            if self.NEW_SCHEMA:
                 r_name = r['name'].rstrip('.') + '.'
                 r_type = r['type']
                 if PRETTY_IPV6_PTR: # only if activated
@@ -1445,7 +1454,7 @@ class Record(object):
         final_records = []
         records = sorted(records, key = lambda item: (item["name"], item["type"], item["changetype"]))
         for key, group in itertools.groupby(records, lambda item: (item["name"], item["type"], item["changetype"])):
-            if NEW_SCHEMA:
+            if self.NEW_SCHEMA:
                 r_name = key[0]
                 r_type = key[1]
                 r_changetype = key[2]
@@ -1498,12 +1507,12 @@ class Record(object):
         postdata_for_new = {"rrsets": final_records}
         logging.debug(postdata_for_new)
         logging.debug(postdata_for_delete)
-        logging.info(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain)))
+        logging.info(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain)))
         try:
             headers = {}
-            headers['X-API-Key'] = PDNS_API_KEY
-            jdata1 = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain)), headers=headers, method='PATCH', data=postdata_for_delete)
-            jdata2 = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain)), headers=headers, method='PATCH', data=postdata_for_new)
+            headers['X-API-Key'] = self.PDNS_API_KEY
+            jdata1 = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain)), headers=headers, method='PATCH', data=postdata_for_delete)
+            jdata2 = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain)), headers=headers, method='PATCH', data=postdata_for_new)
 
             if 'error' in jdata2.keys():
                 logging.error('Cannot apply record changes.')
@@ -1565,7 +1574,7 @@ class Record(object):
         Delete a record from domain
         """
         headers = {}
-        headers['X-API-Key'] = PDNS_API_KEY
+        headers['X-API-Key'] = self.PDNS_API_KEY
         data = {"rrsets": [
                     {
                         "name": self.name.rstrip('.') + '.',
@@ -1577,7 +1586,7 @@ class Record(object):
                 ]
             }
         try:
-            jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain)), headers=headers, method='PATCH', data=data)
+            jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain)), headers=headers, method='PATCH', data=data)
             logging.debug(jdata)
             return {'status': 'ok', 'msg': 'Record was removed successfully'}
         except:
@@ -1619,9 +1628,9 @@ class Record(object):
         Update single record
         """
         headers = {}
-        headers['X-API-Key'] = PDNS_API_KEY
+        headers['X-API-Key'] = self.PDNS_API_KEY
 
-        if NEW_SCHEMA:
+        if self.NEW_SCHEMA:
             data = {"rrsets": [
                         {
                             "name": self.name + '.',
@@ -1657,7 +1666,7 @@ class Record(object):
                     ]
                 }
         try:
-            jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain)), headers=headers, method='PATCH', data=data)
+            jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain)), headers=headers, method='PATCH', data=data)
             logging.debug("dyndns data: {0}".format(data))
             return {'status': 'ok', 'msg': 'Record was updated successfully'}
         except Exception as e:
@@ -1666,8 +1675,8 @@ class Record(object):
 
     def update_db_serial(self, domain):
         headers = {}
-        headers['X-API-Key'] = PDNS_API_KEY
-        jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain)), headers=headers, method='GET')
+        headers['X-API-Key'] = self.PDNS_API_KEY
+        jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/localhost/zones/{0}'.format(domain)), headers=headers, method='GET')
         serial = jdata['serial']
 
         domain = Domain.query.filter(Domain.name==domain).first()
@@ -1688,16 +1697,21 @@ class Server(object):
     def __init__(self, server_id=None, server_config=None):
         self.server_id = server_id
         self.server_config = server_config
+        # PDNS configs
+        self.PDNS_STATS_URL = Setting().get('pdns_api_url')
+        self.PDNS_API_KEY = Setting().get('pdns_api_key')
+        self.PDNS_VERSION = Setting().get('pdns_version')
+        self.API_EXTENDED_URL = utils.pdns_api_extended_uri(self.PDNS_VERSION)
 
     def get_config(self):
         """
         Get server config
         """
         headers = {}
-        headers['X-API-Key'] = PDNS_API_KEY
+        headers['X-API-Key'] = self.PDNS_API_KEY
 
         try:
-            jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/{0}/config'.format(self.server_id)), headers=headers, method='GET')
+            jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/{0}/config'.format(self.server_id)), headers=headers, method='GET')
             return jdata
         except:
             logging.error("Can not get server configuration.")
@@ -1709,10 +1723,10 @@ class Server(object):
         Get server statistics
         """
         headers = {}
-        headers['X-API-Key'] = PDNS_API_KEY
+        headers['X-API-Key'] = self.PDNS_API_KEY
 
         try:
-            jdata = utils.fetch_json(urljoin(PDNS_STATS_URL, API_EXTENDED_URL + '/servers/{0}/statistics'.format(self.server_id)), headers=headers, method='GET')
+            jdata = utils.fetch_json(urljoin(self.PDNS_STATS_URL, self.API_EXTENDED_URL + '/servers/{0}/statistics'.format(self.server_id)), headers=headers, method='GET')
             return jdata
         except:
             logging.error("Can not get server statistics.")
diff --git a/app/templates/admin_setting_pdns.html b/app/templates/admin_setting_pdns.html
index 2508859..6405108 100644
--- a/app/templates/admin_setting_pdns.html
+++ b/app/templates/admin_setting_pdns.html
@@ -25,31 +25,30 @@
             </div>
             <!-- /.box-header -->
             <!-- form start -->
-            <form role="form" method="post" action="">
+            <form role="form" method="post" data-toggle="validator">
                 <input type="hidden" name="create" value="{{ create }}">
                 <div class="box-body">
-                    {% if error %}
+                    {% if not SETTING.get('pdns_api_url') or not SETTING.get('pdns_api_key') or not SETTING.get('pdns_version') %}
                         <div class="alert alert-danger alert-dismissible">
                             <button type="button" class="close" data-dismiss="alert" aria-hidden="true">&times;</button>
                             <h4><i class="icon fa fa-ban"></i> Error!</h4>
-                            {{ error }}
+                            Please complete your PowerDNS API configuration before continuing
                          </div>
-                        <span class="help-block">{{ error }}</span>
                     {% endif %}
                     <div class="form-group has-feedback">
                         <label class="control-label" for="pdns_api_url">PDNS API URL</label>
-                        <input type="text" class="form-control" placeholder="PowerDNS API url" name="pdns_api_url" value="{{ pdns_api_url }}">
-                        <span class="form-control-feedback"></span>
+                        <input type="url" class="form-control" placeholder="PowerDNS API url" name="pdns_api_url" data-error="Please input a valid PowerDNS API URL" required value="{{ pdns_api_url }}">
+                        <span class="help-block with-errors"></span>
                     </div>
                     <div class="form-group has-feedback">
                         <label class="control-label" for="pdns_api_key">PDNS API KEY</label>
-                        <input type="text" class="form-control" placeholder="PowerDNS API key" name="pdns_api_key" value="{{ pdns_api_key }}">
-                        <span class="form-control-feedback"></span>
+                        <input type="text" class="form-control" placeholder="PowerDNS API key" name="pdns_api_key" data-error="Please input a valid PowerDNS API key" required value="{{ pdns_api_key }}">
+                        <span class="help-block with-errors"></span>
                     </div>
                     <div class="form-group has-feedback">
                         <label class="control-label" for="pdns_version">PDNS VERSION</label>
-                        <input type="text" class="form-control" placeholder="PowerDNS version" name="pdns_version" value="{{ pdns_version }}">
-                        <span class="form-control-feedback"></span>
+                        <input type="text" class="form-control" placeholder="PowerDNS version" name="pdns_version" data-error="Please input PowerDNS version" required value="{{ pdns_version }}">
+                        <span class="help-block with-errors"></span>
                     </div>
                 </div>
                 <div class="box-footer">
@@ -72,4 +71,7 @@
 </section>
 {% endblock %}
 {% block extrascripts %}
+    {% assets "js_validation" -%}
+      <script type="text/javascript" src="{{ ASSET_URL }}"></script>
+    {%- endassets %}
 {% endblock %}
\ No newline at end of file
diff --git a/app/templates/dashboard.html b/app/templates/dashboard.html
index 364883e..102214a 100644
--- a/app/templates/dashboard.html
+++ b/app/templates/dashboard.html
@@ -156,7 +156,7 @@
 {% endblock %}
 {% block extrascripts %}
 <script>
-    PDNS_VERSION = '{{ pdns_version }}'
+    PDNS_VERSION = '{{ SETTING.get("pdns_version") }}'
     // set up history data table
     $("#tbl_history").DataTable({
         "paging" : false,
diff --git a/app/templates/domain.html b/app/templates/domain.html
index 9d4a94d..bb351db 100644
--- a/app/templates/domain.html
+++ b/app/templates/domain.html
@@ -104,7 +104,7 @@
 {% endblock %}
 {% block extrascripts %}
 <script>
-    PDNS_VERSION = '{{ pdns_version }}'
+    PDNS_VERSION = '{{ SETTING.get("pdns_version") }}'
     // superglobals
     window.records_allow_edit = {{ editable_records|tojson }};
     window.nEditing = null;
diff --git a/app/views.py b/app/views.py
index 3800f70..f7bcb43 100644
--- a/app/views.py
+++ b/app/views.py
@@ -37,14 +37,6 @@ app.jinja_env.filters['display_master_name'] = utils.display_master_name
 app.jinja_env.filters['display_second_to_time'] = utils.display_time
 app.jinja_env.filters['email_to_gravatar_url'] = utils.email_to_gravatar_url
 
-# Flag for pdns v4.x.x
-# TODO: Find another way to do this
-PDNS_VERSION = app.config['PDNS_VERSION']
-if StrictVersion(PDNS_VERSION) >= StrictVersion('4.0.0'):
-    NEW_SCHEMA = True
-else:
-    NEW_SCHEMA = False
-
 
 @app.context_processor
 def inject_sitename():
@@ -447,6 +439,9 @@ def saml_logout():
 @app.route('/dashboard', methods=['GET', 'POST'])
 @login_required
 def dashboard():
+    if not Setting().get('pdns_api_url') or not Setting().get('pdns_api_key') or not Setting().get('pdns_version'):
+        return redirect(url_for('admin_setting_pdns'))
+
     if not app.config.get('BG_DOMAIN_UPDATES'):
         logging.debug('Update domains in foreground')
         d = Domain().update()
@@ -465,7 +460,7 @@ def dashboard():
     else:
         uptime = 0
 
-    return render_template('dashboard.html', domain_count=domain_count, users=users, history_number=history_number, uptime=uptime, histories=history, dnssec_adm_only=app.config['DNSSEC_ADMINS_ONLY'], pdns_version=app.config['PDNS_VERSION'], show_bg_domain_button=app.config['BG_DOMAIN_UPDATES'])
+    return render_template('dashboard.html', domain_count=domain_count, users=users, history_number=history_number, uptime=uptime, histories=history, dnssec_adm_only=app.config['DNSSEC_ADMINS_ONLY'], show_bg_domain_button=app.config['BG_DOMAIN_UPDATES'])
 
 
 @app.route('/dashboard-domains', methods=['GET'])
@@ -571,7 +566,7 @@ def domain(domain_name):
 
     records = []
     #TODO: This should be done in the "model" instead of "view"
-    if NEW_SCHEMA:
+    if StrictVersion(Setting().get('pdns_version')) >= StrictVersion('4.0.0'):
         for jr in jrecords:
             if jr['type'] in app.config['RECORDS_ALLOW_EDIT']:
                 for subrecord in jr['records']:
@@ -591,7 +586,7 @@ def domain(domain_name):
         editable_records = app.config['FORWARD_RECORDS_ALLOW_EDIT']
     else:
         editable_records = app.config['REVERSE_RECORDS_ALLOW_EDIT']
-    return render_template('domain.html', domain=domain, records=records, editable_records=editable_records, quick_edit=quick_edit, pdns_version=app.config['PDNS_VERSION'])
+    return render_template('domain.html', domain=domain, records=records, editable_records=editable_records, quick_edit=quick_edit)
 
 
 @app.route('/admin/domain/add', methods=['GET', 'POST'])
@@ -982,7 +977,7 @@ def create_template_from_zone():
                 if zone_info:
                     jrecords = zone_info['records']
 
-                if NEW_SCHEMA:
+                if StrictVersion(Setting().get('pdns_version')) >= StrictVersion('4.0.0'):
                     for jr in jrecords:
                         if jr['type'] in app.config['RECORDS_ALLOW_EDIT']:
                             name = '@' if jr['name'] == domain_name else re.sub('\.{}$'.format(domain_name), '', jr['name'])
@@ -1086,6 +1081,9 @@ def delete_template(template):
 @login_required
 @admin_role_required
 def admin():
+    if not Setting().get('pdns_api_url') or not Setting().get('pdns_api_key') or not Setting().get('pdns_version'):
+        return redirect(url_for('admin_setting_pdns'))
+
     domains = Domain.query.all()
     users = User.query.all()
 
diff --git a/config_template.py b/config_template.py
index acfea5f..f1b7666 100644
--- a/config_template.py
+++ b/config_template.py
@@ -34,40 +34,6 @@ SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(basedir, 'pdns.db')
 SQLALCHEMY_MIGRATE_REPO = os.path.join(basedir, 'db_repository')
 SQLALCHEMY_TRACK_MODIFICATIONS = True
 
-
-## AD CONFIG
-#LDAP_TYPE = 'ad'
-#LDAP_URI = 'ldaps://your-ad-server:636'
-#LDAP_USERNAME = 'cn=dnsuser,ou=Users,dc=domain,dc=local'
-#LDAP_PASSWORD = 'dnsuser'
-#LDAP_SEARCH_BASE = 'dc=domain,dc=local'
-## You may prefer 'userPrincipalName' instead
-#LDAP_USERNAMEFIELD = 'sAMAccountName'
-## AD Group that you would like to have accesss to web app
-#LDAP_FILTER = 'memberof=cn=DNS_users,ou=Groups,dc=domain,dc=local'
-
-# Github Oauth
-GITHUB_OAUTH_ENABLE = False
-GITHUB_OAUTH_KEY = ''
-GITHUB_OAUTH_SECRET = ''
-GITHUB_OAUTH_SCOPE = 'email'
-GITHUB_OAUTH_URL = 'http://127.0.0.1:9191/api/v3/'
-GITHUB_OAUTH_TOKEN = 'http://127.0.0.1:9191/oauth/token'
-GITHUB_OAUTH_AUTHORIZE = 'http://127.0.0.1:9191/oauth/authorize'
-
-
-# Google OAuth
-GOOGLE_OAUTH_ENABLE = False
-GOOGLE_OAUTH_CLIENT_ID = ' '
-GOOGLE_OAUTH_CLIENT_SECRET = ' '
-GOOGLE_REDIRECT_URI = '/user/authorized'
-GOOGLE_TOKEN_URL = 'https://accounts.google.com/o/oauth2/token'
-GOOGLE_TOKEN_PARAMS = {
-    'scope': 'email profile'
-}
-GOOGLE_AUTHORIZE_URL='https://accounts.google.com/o/oauth2/auth'
-GOOGLE_BASE_URL='https://www.googleapis.com/oauth2/v1/'
-
 # SAML Authnetication
 SAML_ENABLED = False
 SAML_DEBUG = True
@@ -141,12 +107,6 @@ SAML_LOGOUT = False
 #for example redirect to google.com after successful saml logout
 #SAML_LOGOUT_URL = 'https://google.com'
 
-
-# POWERDNS CONFIG
-PDNS_STATS_URL = 'http://172.16.214.131:8081/'
-PDNS_API_KEY = 'you never know'
-PDNS_VERSION = '4.1.1'
-
 # RECORDS ALLOWED TO EDIT
 RECORDS_ALLOW_EDIT = ['A', 'AAAA', 'CAA', 'CNAME', 'MX', 'PTR', 'SPF', 'SRV', 'TXT', 'LOC', 'NS', 'PTR', 'SOA']
 FORWARD_RECORDS_ALLOW_EDIT = ['A', 'AAAA', 'CAA', 'CNAME', 'MX', 'PTR', 'SPF', 'SRV', 'TXT', 'LOC' 'NS']