diff --git a/src/apptask.js b/src/apptask.js
index 7eb5c1762..484bc88a9 100644
--- a/src/apptask.js
+++ b/src/apptask.js
@@ -341,7 +341,7 @@ function waitForDnsPropagation(app, callback) {
     sysinfo.getPublicIp(function (error, ip) {
         if (error) return callback(error);
 
-        domains.waitForDnsRecord(app.fqdn, app.domain, ip, 'A', { interval: 5000, times: 120 }, callback);
+        domains.waitForDnsRecord(app.fqdn, app.domain, ip, { interval: 5000, times: 120 }, callback);
     });
 }
 
diff --git a/src/dns/noop.js b/src/dns/noop.js
index d65fc0249..eec3bcc29 100644
--- a/src/dns/noop.js
+++ b/src/dns/noop.js
@@ -46,11 +46,10 @@ function del(dnsConfig, zoneName, subdomain, type, values, callback) {
     return callback();
 }
 
-function waitForDns(domain, zoneName, value, type, options, callback) {
+function waitForDns(domain, zoneName, value, options, callback) {
     assert.strictEqual(typeof domain, 'string');
     assert.strictEqual(typeof zoneName, 'string');
-    assert(typeof value === 'string' || util.isRegExp(value));
-    assert(type === 'A' || type === 'CNAME' || type === 'TXT');
+    assert.strictEqual(typeof value, 'string');
     assert(options && typeof options === 'object'); // { interval: 5000, times: 50000 }
     assert.strictEqual(typeof callback, 'function');
 
diff --git a/src/dns/waitfordns.js b/src/dns/waitfordns.js
index 0df8b553b..82e4f8e77 100644
--- a/src/dns/waitfordns.js
+++ b/src/dns/waitfordns.js
@@ -6,13 +6,11 @@ var assert = require('assert'),
     async = require('async'),
     debug = require('debug')('box:dns/waitfordns'),
     dns = require('../native-dns.js'),
-    DomainError = require('../domains.js').DomainError,
-    util = require('util');
+    DomainError = require('../domains.js').DomainError;
 
-function isChangeSynced(domain, value, type, nameserver, callback) {
+function isChangeSynced(domain, value, nameserver, callback) {
     assert.strictEqual(typeof domain, 'string');
-    assert(util.isRegExp(value));
-    assert.strictEqual(typeof type, 'string');
+    assert.strictEqual(typeof value, 'string');
     assert.strictEqual(typeof nameserver, 'string');
     assert.strictEqual(typeof callback, 'function');
 
@@ -24,7 +22,7 @@ function isChangeSynced(domain, value, type, nameserver, callback) {
         }
 
         async.every(nsIps, function (nsIp, iteratorCallback) {
-            dns.resolve(domain, type, { server: nsIp, timeout: 5000 }, function (error, answer) {
+            dns.resolve(domain, 'A', { server: nsIp, timeout: 5000 }, function (error, answer) {
                 if (error && error.code === 'ETIMEDOUT') {
                     debug('nameserver %s (%s) timed out when trying to resolve %s', nameserver, nsIp, domain);
                     return iteratorCallback(null, true); // should be ok if dns server is down
@@ -36,17 +34,13 @@ function isChangeSynced(domain, value, type, nameserver, callback) {
                 }
 
                 if (!answer || answer.length === 0) {
-                    debug('bad answer from nameserver %s (%s) resolving %s (%s)', nameserver, nsIp, domain, type);
+                    debug('bad answer from nameserver %s (%s) resolving %s', nameserver, nsIp, domain);
                     return iteratorCallback(null, false);
                 }
 
                 debug('isChangeSynced: ns: %s (%s), name:%s Actual:%j Expecting:%s', nameserver, nsIp, domain, answer, value);
 
-                var match = answer.some(function (a) {
-                    return ((type === 'A' && value.test(a)) ||
-                            (type === 'CNAME' && value.test(a)) ||
-                            (type === 'TXT' && value.test(a)));
-                });
+                var match = answer.some(a => a === value);
 
                 if (match) return iteratorCallback(null, true); // done!
 
@@ -58,19 +52,13 @@ function isChangeSynced(domain, value, type, nameserver, callback) {
 }
 
 // check if IP change has propagated to every nameserver
-function waitForDns(domain, zoneName, value, type, options, callback) {
+function waitForDns(domain, zoneName, value, options, callback) {
     assert.strictEqual(typeof domain, 'string');
     assert.strictEqual(typeof zoneName, 'string');
-    assert(typeof value === 'string' || util.isRegExp(value));
-    assert(type === 'A' || type === 'CNAME' || type === 'TXT');
+    assert.strictEqual(typeof value, 'string');
     assert(options && typeof options === 'object'); // { interval: 5000, times: 50000 }
     assert.strictEqual(typeof callback, 'function');
 
-    if (typeof value === 'string') {
-        // http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
-        value = new RegExp('^' + value.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&') + '$');
-    }
-
     debug('waitForIp: domain %s to be %s in zone %s.', domain, value, zoneName);
 
     var attempt = 1;
@@ -80,7 +68,7 @@ function waitForDns(domain, zoneName, value, type, options, callback) {
         dns.resolveNs(zoneName, function (error, nameservers) {
             if (error || !nameservers) return retryCallback(error || new DomainError(DomainError.EXTERNAL_ERROR, 'Unable to get nameservers'));
 
-            async.every(nameservers, isChangeSynced.bind(null, domain, value, type), function (error, synced) {
+            async.every(nameservers, isChangeSynced.bind(null, domain, value), function (error, synced) {
                 debug('waitForIp: %s %s ns: %j', domain, synced ? 'done' : 'not done', nameservers);
 
                 retryCallback(synced ? null : new DomainError(DomainError.EXTERNAL_ERROR, 'ETRYAGAIN'));
diff --git a/src/domains.js b/src/domains.js
index 2facf5b3b..315ed5852 100644
--- a/src/domains.js
+++ b/src/domains.js
@@ -313,18 +313,18 @@ function removeDnsRecords(subdomain, domain, type, values, callback) {
     });
 }
 
-function waitForDnsRecord(fqdn, domain, value, type, options, callback) {
+// only wait for A record
+function waitForDnsRecord(fqdn, domain, value, options, callback) {
     assert.strictEqual(typeof fqdn, 'string');
     assert.strictEqual(typeof domain, 'string');
-    assert(typeof value === 'string' || util.isRegExp(value));
-    assert(type === 'A' || type === 'CNAME' || type === 'TXT');
+    assert.strictEqual(typeof value, 'string');
     assert(options && typeof options === 'object'); // { interval: 5000, times: 50000 }
     assert.strictEqual(typeof callback, 'function');
 
     get(domain, function (error, result) {
         if (error) return callback(error);
 
-        api(result.provider).waitForDns(fqdn, result ? result.zoneName : domain, value, type, options, callback);
+        api(result.provider).waitForDns(fqdn, result ? result.zoneName : domain, value, options, callback);
     });
 }
 
diff --git a/src/setup.js b/src/setup.js
index 2f23345bf..5441049b9 100644
--- a/src/setup.js
+++ b/src/setup.js
@@ -162,7 +162,7 @@ function configureWebadmin(callback) {
         addWebadminDnsRecord(ip, config.adminDomain(), function (error) {
             if (error) return configureReverseProxy(error);
 
-            domains.waitForDnsRecord(config.adminFqdn(), config.adminDomain(), ip, 'A', { interval: 30000, times: 50000 }, function (error) {
+            domains.waitForDnsRecord(config.adminFqdn(), config.adminDomain(), ip, { interval: 30000, times: 50000 }, function (error) {
                 if (error) return configureReverseProxy(error);
 
                 gWebadminStatus.dns = true;