diff --git a/package.json b/package.json
index 84b3c990e..237dc61c5 100644
--- a/package.json
+++ b/package.json
@@ -47,7 +47,7 @@
   },
   "dependencies": {
     "node-pre-gyp": "git+https://github.com/mapbox/node-pre-gyp.git#c88d6a04",
-    "nan": "^1.6.0"
+    "nan": "^2.0.9"
   },
   "bundledDependencies": [
     "node-pre-gyp"
diff --git a/src/device.cc b/src/device.cc
index ca90c693f..26584f598 100644
--- a/src/device.cc
+++ b/src/device.cc
@@ -2,7 +2,7 @@
 #include <string.h>
 
 #define STRUCT_TO_V8(TARGET, STR, NAME) \
-		TARGET->ForceSet(V8STR(#NAME), NanNew<Uint32>((uint32_t) (STR).NAME), CONST_PROP);
+		TARGET->ForceSet(V8STR(#NAME), Nan::New<Uint32>((uint32_t) (STR).NAME).ToLocalChecked(), CONST_PROP);
 
 #define CHECK_OPEN() \
 		if (!self->device_handle){THROW_ERROR("Device is not opened");}
@@ -12,7 +12,7 @@
 static v8::Persistent<v8::FunctionTemplate> device_constructor;
 
 Handle<Object> makeBuffer(const unsigned char* ptr, unsigned length) {
-	return NanNewBufferHandle((char*) ptr, (uint32_t) length);
+	return Nan::NewBuffer((char*) ptr, (uint32_t) length).ToLocalChecked();
 }
 
 Device::Device(libusb_device* d): device(d), device_handle(0) {
@@ -28,24 +28,24 @@ Device::~Device(){
 }
 
 // Map pinning each libusb_device to a particular V8 instance
-std::map<libusb_device*, _NanWeakCallbackInfo<Value, libusb_device>*> Device::byPtr;
+std::map<libusb_device*, Nan::WeakCallbackInfo<std::pair<v8::Value, libusb_device*>>*> Device::byPtr;
 
-NAN_WEAK_CALLBACK(DeviceWeakCallback) {
-	Device::unpin(data.GetParameter());
+void DeviceWeakCallback (const Nan::WeakCallbackInfo<std::pair<v8::Value, libusb_device*>> &data) {
+	Device::unpin(data.GetParameter()->second);
 }
 
 // Get a V8 instance for a libusb_device: either the existing one from the map,
 // or create a new one and add it to the map.
-Handle<Value> Device::get(libusb_device* dev){
+Local<Value> Device::get(libusb_device* dev){
 	auto it = byPtr.find(dev);
 	if (it != byPtr.end()){
-		return NanNew(it->second->persistent);
+		return Nan::New<v8::Value>(it->second->GetParameter()->first);
 	}else{
-		Local<FunctionTemplate> constructorHandle = NanNew<v8::FunctionTemplate>(device_constructor);
-		v8::Handle<v8::Value> argv[1] = { EXTERNAL_NEW(new Device(dev)) };
-		Handle<Value> v = constructorHandle->GetFunction()->NewInstance(1, argv);
-		auto p = NanMakeWeakPersistent(v, dev, DeviceWeakCallback);
-		byPtr.insert(std::make_pair(dev, p));
+		Local<FunctionTemplate> constructorHandle = Nan::New<v8::FunctionTemplate>(device_constructor).ToLocalChecked();
+		v8::Local<v8::Value> argv[1] = { EXTERNAL_NEW(new Device(dev)) };
+		v8::Local<v8::Value> v = constructorHandle->GetFunction()->NewInstance(1, argv);
+		auto p = Nan::MakeWeakPersistent(v, dev, DeviceWeakCallback);
+		byPtr.insert(std::make_pair(dev, std::make_pair(p, dev)));
 		return v;
 	}
 }
@@ -58,13 +58,13 @@ void Device::unpin(libusb_device* device) {
 static NAN_METHOD(deviceConstructor) {
 	ENTER_CONSTRUCTOR_POINTER(Device, 1);
 
-	args.This()->ForceSet(V8SYM("busNumber"),
-		NanNew<Uint32>((uint32_t) libusb_get_bus_number(self->device)), CONST_PROP);
-	args.This()->ForceSet(V8SYM("deviceAddress"),
-		NanNew<Uint32>((uint32_t) libusb_get_device_address(self->device)), CONST_PROP);
+	info.This()->ForceSet(V8SYM("busNumber"),
+		Nan::New<Uint32>((uint32_t) libusb_get_bus_number(self->device)).ToLocalChecked(), CONST_PROP);
+	info.This()->ForceSet(V8SYM("deviceAddress"),
+		Nan::New<Uint32>((uint32_t) libusb_get_device_address(self->device)).ToLocalChecked(), CONST_PROP);
 
-	Local<Object> v8dd = NanNew<Object>();
-	args.This()->ForceSet(V8SYM("deviceDescriptor"), v8dd, CONST_PROP);
+	Local<Object> v8dd = Nan::New<Object>().ToLocalChecked();
+	info.This()->ForceSet(V8SYM("deviceDescriptor"), v8dd, CONST_PROP);
 
 	struct libusb_device_descriptor dd;
 	CHECK_USB(libusb_get_device_descriptor(self->device, &dd));
@@ -87,14 +87,14 @@ static NAN_METHOD(deviceConstructor) {
 	uint8_t port_numbers[MAX_PORTS];
 	int ret = libusb_get_port_numbers(self->device, &port_numbers[0], MAX_PORTS);
 	CHECK_USB(ret);
-	Local<Array> array = NanNew<Array>(ret);
+	Local<Array> array = Nan::New<Array>(ret);
 	for (int i = 0; i < ret; ++ i) {
-		array->Set(i, NanNew(port_numbers[i]));
+		array->Set(i, Nan::New(port_numbers[i]).ToLocalChecked());
 	}
 
-	args.This()->ForceSet(V8SYM("portNumbers"), array, CONST_PROP);
+	info.This()->ForceSet(V8SYM("portNumbers"), array, CONST_PROP);
 
-	NanReturnValue(args.This());
+	info.GetReturnValue().Set(info.This());
 }
 
 NAN_METHOD(Device_GetConfigDescriptor) {
@@ -103,7 +103,7 @@ NAN_METHOD(Device_GetConfigDescriptor) {
 	libusb_config_descriptor* cdesc;
 	CHECK_USB(libusb_get_active_config_descriptor(self->device, &cdesc));
 
-	Local<Object> v8cdesc = NanNew<Object>();
+	Local<Object> v8cdesc = Nan::New<Object>().ToLocalChecked();
 
 	STRUCT_TO_V8(v8cdesc, *cdesc, bLength)
 	STRUCT_TO_V8(v8cdesc, *cdesc, bDescriptorType)
@@ -113,24 +113,24 @@ NAN_METHOD(Device_GetConfigDescriptor) {
 	STRUCT_TO_V8(v8cdesc, *cdesc, iConfiguration)
 	STRUCT_TO_V8(v8cdesc, *cdesc, bmAttributes)
 	// Libusb 1.0 typo'd bMaxPower as MaxPower
-	v8cdesc->ForceSet(V8STR("bMaxPower"), NanNew<Uint32>((uint32_t) cdesc->MaxPower), CONST_PROP);
+	v8cdesc->ForceSet(V8STR("bMaxPower"), Nan::New<Uint32>((uint32_t) cdesc->MaxPower).ToLocalChecked(), CONST_PROP);
 
 	v8cdesc->ForceSet(V8SYM("extra"), makeBuffer(cdesc->extra, cdesc->extra_length), CONST_PROP);
 
-	Local<Array> v8interfaces = NanNew<Array>(cdesc->bNumInterfaces);
+	Local<Array> v8interfaces = Nan::New<Array>(cdesc->bNumInterfaces);
 	v8cdesc->ForceSet(V8SYM("interfaces"), v8interfaces);
 
 	for (int idxInterface = 0; idxInterface < cdesc->bNumInterfaces; idxInterface++) {
 		int numAltSettings = cdesc->interface[idxInterface].num_altsetting;
 
-		Local<Array> v8altsettings = NanNew<Array>(numAltSettings);
+		Local<Array> v8altsettings = Nan::New<Array>(numAltSettings);
 		v8interfaces->Set(idxInterface, v8altsettings);
 
 		for (int idxAltSetting = 0; idxAltSetting < numAltSettings; idxAltSetting++) {
 			const libusb_interface_descriptor& idesc =
 				cdesc->interface[idxInterface].altsetting[idxAltSetting];
 
-			Local<Object> v8idesc = NanNew<Object>();
+			Local<Object> v8idesc = Nan::New<Object>().ToLocalChecked();
 			v8altsettings->Set(idxAltSetting, v8idesc);
 
 			STRUCT_TO_V8(v8idesc, idesc, bLength)
@@ -145,12 +145,12 @@ NAN_METHOD(Device_GetConfigDescriptor) {
 
 			v8idesc->ForceSet(V8SYM("extra"), makeBuffer(idesc.extra, idesc.extra_length), CONST_PROP);
 
-			Local<Array> v8endpoints = NanNew<Array>(idesc.bNumEndpoints);
+			Local<Array> v8endpoints = Nan::New<Array>(idesc.bNumEndpoints);
 			v8idesc->ForceSet(V8SYM("endpoints"), v8endpoints, CONST_PROP);
 			for (int idxEndpoint = 0; idxEndpoint < idesc.bNumEndpoints; idxEndpoint++){
 				const libusb_endpoint_descriptor& edesc = idesc.endpoint[idxEndpoint];
 
-				Local<Object> v8edesc = NanNew<Object>();
+				Local<Object> v8edesc = Nan::New<Object>().ToLocalChecked();
 				v8endpoints->Set(idxEndpoint, v8edesc);
 
 				STRUCT_TO_V8(v8edesc, edesc, bLength)
@@ -168,7 +168,7 @@ NAN_METHOD(Device_GetConfigDescriptor) {
 	}
 
 	libusb_free_config_descriptor(cdesc);
-	NanReturnValue(v8cdesc);
+	info.GetReturnValue().Set(v8cdesc);
 }
 
 NAN_METHOD(Device_Open) {
@@ -176,7 +176,6 @@ NAN_METHOD(Device_Open) {
 	if (!self->device_handle){
 		CHECK_USB(libusb_open(self->device, &self->device_handle));
 	}
-	NanReturnValue(NanUndefined());
 }
 
 NAN_METHOD(Device_Close) {
@@ -187,7 +186,6 @@ NAN_METHOD(Device_Close) {
 	}else{
 		THROW_ERROR("Can't close device with a pending request");
 	}
-	NanReturnValue(NanUndefined());
 }
 
 struct Req{
@@ -205,20 +203,20 @@ struct Req{
 	}
 
 	static void default_after(uv_work_t *req){
-		NanScope();
+		Nan::HandleScope scope;
 		auto baton = (Req*) req->data;
 
 		auto device = NanObjectWrapHandle(baton->device);
 		baton->device->unref();
 
-		if (!NanNew(baton->callback).IsEmpty()) {
+		if (!Nan::New(baton->callback).ToLocalChecked().IsEmpty()) {
 			Handle<Value> error = NanUndefined();
 			if (baton->errcode < 0){
 				error = libusbException(baton->errcode);
 			}
 			Handle<Value> argv[1] = {error};
 			TryCatch try_catch;
-			NanMakeCallback(device, NanNew(baton->callback), 1, argv);
+			Nan::MakeCallback(device, Nan::New(baton->callback).ToLocalChecked(), 1, argv);
 			if (try_catch.HasCaught()) {
 				FatalException(try_catch);
 			}
@@ -235,7 +233,6 @@ struct Device_Reset: Req{
 		CALLBACK_ARG(0);
 		auto baton = new Device_Reset;
 		baton->submit(self, callback, &backend, &default_after);
-		NanReturnValue(NanUndefined());
 	}
 
 	static void backend(uv_work_t *req){
@@ -251,7 +248,7 @@ NAN_METHOD(IsKernelDriverActive) {
 	INT_ARG(interface, 0);
 	int r = libusb_kernel_driver_active(self->device_handle, interface);
 	CHECK_USB(r);
-	NanReturnValue(NanNew<Boolean>(r));
+	info.GetReturnValue().Set(Nan::New<Boolean>(r));
 }
 
 NAN_METHOD(DetachKernelDriver) {
@@ -260,7 +257,6 @@ NAN_METHOD(DetachKernelDriver) {
 	int interface;
 	INT_ARG(interface, 0);
 	CHECK_USB(libusb_detach_kernel_driver(self->device_handle, interface));
-	NanReturnValue(NanUndefined());
 }
 
 NAN_METHOD(AttachKernelDriver) {
@@ -269,7 +265,6 @@ NAN_METHOD(AttachKernelDriver) {
 	int interface;
 	INT_ARG(interface, 0);
 	CHECK_USB(libusb_attach_kernel_driver(self->device_handle, interface));
-	NanReturnValue(NanUndefined());
 }
 
 NAN_METHOD(Device_ClaimInterface) {
@@ -278,7 +273,6 @@ NAN_METHOD(Device_ClaimInterface) {
 	int interface;
 	INT_ARG(interface, 0);
 	CHECK_USB(libusb_claim_interface(self->device_handle, interface));
-	NanReturnValue(NanUndefined());
 }
 
 struct Device_ReleaseInterface: Req{
@@ -294,7 +288,6 @@ struct Device_ReleaseInterface: Req{
 		baton->interface = interface;
 		baton->submit(self, callback, &backend, &default_after);
 
-		NanReturnValue(NanUndefined());
 	}
 
 	static void backend(uv_work_t *req){
@@ -318,7 +311,6 @@ struct Device_SetInterface: Req{
 		baton->interface = interface;
 		baton->altsetting = altsetting;
 		baton->submit(self, callback, &backend, &default_after);
-		NanReturnValue(NanUndefined());
 	}
 
 	static void backend(uv_work_t *req){
@@ -329,8 +321,8 @@ struct Device_SetInterface: Req{
 };
 
 void Device::Init(Handle<Object> target){
-	Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(deviceConstructor);
-	tpl->SetClassName(NanNew("Device"));
+	Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(deviceConstructor).ToLocalChecked();
+	tpl->SetClassName(Nan::New("Device").ToLocalChecked());
 	tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
 	NODE_SET_PROTOTYPE_METHOD(tpl, "__getConfigDescriptor", Device_GetConfigDescriptor);
@@ -347,5 +339,5 @@ void Device::Init(Handle<Object> target){
 	NODE_SET_PROTOTYPE_METHOD(tpl, "__attachKernelDriver", AttachKernelDriver);
 
 	NanAssignPersistent(device_constructor, tpl);
-	target->Set(NanNew("Device"), tpl->GetFunction());
+	target->Set(Nan::New("Device").ToLocalChecked(), tpl->GetFunction());
 }
diff --git a/src/helpers.h b/src/helpers.h
index ea42c7ed3..0fb26382b 100644
--- a/src/helpers.h
+++ b/src/helpers.h
@@ -5,42 +5,36 @@
 
 using namespace v8;
 
-#define V8STR(str) NanNew<String>(str)
-#define V8SYM(str) NanNew<String>(str)
+#define V8STR(str) Nan::New<String>(str).ToLocalChecked()
+#define V8SYM(str) Nan::New<String>(str).ToLocalChecked()
 
-#define THROW_BAD_ARGS(FAIL_MSG) return NanThrowTypeError(FAIL_MSG);
-#define THROW_ERROR(FAIL_MSG) return NanThrowError(FAIL_MSG);
+#define THROW_BAD_ARGS(FAIL_MSG) return Nan::ThrowTypeError(FAIL_MSG);
+#define THROW_ERROR(FAIL_MSG) return Nan::ThrowError(FAIL_MSG);
 #define CHECK_N_ARGS(MIN_ARGS) if (args.Length() < MIN_ARGS) { THROW_BAD_ARGS("Expected " #MIN_ARGS " arguments") }
 
 const PropertyAttribute CONST_PROP = static_cast<PropertyAttribute>(ReadOnly|DontDelete);
 
 inline static void setConst(Handle<Object> obj, const char* const name, Handle<Value> value){
-	obj->ForceSet(NanNew<String>(name), value, CONST_PROP);
+	obj->ForceSet(Nan::New<String>(name).ToLocalChecked(), value, CONST_PROP);
 }
 
 #define ENTER_CONSTRUCTOR(MIN_ARGS) \
-	NanScope();              \
-	if (!args.IsConstructCall()) return NanThrowError("Must be called with `new`!"); \
+	if (!args.IsConstructCall()) return Nan::ThrowError("Must be called with `new`!"); \
 	CHECK_N_ARGS(MIN_ARGS);
 
 #define ENTER_CONSTRUCTOR_POINTER(CLASS, MIN_ARGS) \
 	ENTER_CONSTRUCTOR(MIN_ARGS)                    \
 	if (!args.Length() || !args[0]->IsExternal()){ \
-		return NanThrowError("This type cannot be created directly!"); \
+		return Nan::ThrowError("This type cannot be created directly!"); \
 	}                                               \
 	auto self = static_cast<CLASS*>(External::Cast(*args[0])->Value()); \
 	self->attach(args.This())
 
 #define ENTER_METHOD(CLASS, MIN_ARGS) \
-	NanScope();                \
 	CHECK_N_ARGS(MIN_ARGS);           \
 	auto self = node::ObjectWrap::Unwrap<CLASS>(args.This()); \
 	if (self == NULL) { THROW_BAD_ARGS(#CLASS " method called on invalid object") }
 
-#define ENTER_ACCESSOR(CLASS) \
-		NanScope();                \
-		auto self = node::ObjectWrap::Unwrap<CLASS>(info.Holder());
-
 #define UNWRAP_ARG(CLASS, NAME, ARGNO)     \
 	if (!args[ARGNO]->IsObject())          \
 		THROW_BAD_ARGS("Parameter " #NAME " is not an object"); \
diff --git a/src/node_usb.cc b/src/node_usb.cc
index 8b0101305..230353319 100644
--- a/src/node_usb.cc
+++ b/src/node_usb.cc
@@ -56,12 +56,10 @@ void USBThreadFn(void*){
 }
 #endif
 
-extern "C" void Initialize(Handle<Object> target) {
-	NanScope();
-
+extern "C" void Initialize(Local<Object> target) {
 	// Initialize libusb. On error, halt initialization.
 	int res = libusb_init(&usb_context);
-	target->Set(NanNew<String>("INIT_ERROR"), NanNew<Number>(res));
+	target->Set(Nan::New<String>("INIT_ERROR").ToLocalChecked(), Nan::New<Number>(res));
 	if (res != 0) {
 		return;
 	}
@@ -84,70 +82,67 @@ extern "C" void Initialize(Handle<Object> target) {
 	Device::Init(target);
 	Transfer::Init(target);
 
-	NODE_SET_METHOD(target, "setDebugLevel", SetDebugLevel);
-	NODE_SET_METHOD(target, "getDeviceList", GetDeviceList);
-	NODE_SET_METHOD(target, "_enableHotplugEvents", EnableHotplugEvents);
-	NODE_SET_METHOD(target, "_disableHotplugEvents", DisableHotplugEvents);
+	Nan::SetMethod(target, "setDebugLevel", SetDebugLevel);
+	Nan::SetMethod(target, "getDeviceList", GetDeviceList);
+	Nan::SetMethod(target, "_enableHotplugEvents", EnableHotplugEvents);
+	Nan::SetMethod(target, "_disableHotplugEvents", DisableHotplugEvents);
 	initConstants(target);
 }
 
 NODE_MODULE(usb_bindings, Initialize)
 
 NAN_METHOD(SetDebugLevel) {
-	NanScope();
-	if (args.Length() != 1 || !args[0]->IsUint32() || args[0]->Uint32Value() > 4) {
+	if (info.Length() != 1 || !info[0]->IsUint32() || info[0]->Uint32Value() > 4) {
 		THROW_BAD_ARGS("Usb::SetDebugLevel argument is invalid. [uint:[0-4]]!")
 	}
 
-	libusb_set_debug(usb_context, args[0]->Uint32Value());
-	NanReturnValue(NanUndefined());
+	libusb_set_debug(usb_context, info[0]->Uint32Value());
 }
 
 NAN_METHOD(GetDeviceList) {
-	NanScope();
 	libusb_device **devs;
 	int cnt = libusb_get_device_list(usb_context, &devs);
 	CHECK_USB(cnt);
 
-	Handle<Array> arr = NanNew<Array>(cnt);
+	Local<Array> arr = Nan::New<Array>(cnt);
 
 	for(int i = 0; i < cnt; i++) {
 		arr->Set(i, Device::get(devs[i]));
 	}
 	libusb_free_device_list(devs, true);
-	NanReturnValue(arr);
+	info.GetReturnValue().Set(arr);
 }
 
-Persistent<Object> hotplugThis;
+Nan::Persistent<v8::Object> hotplugThis;
 
 void handleHotplug(std::pair<libusb_device*, libusb_hotplug_event> args){
-	NanScope();
+	Nan::HandleScope scope;
 
 	libusb_device* dev = args.first;
 	libusb_hotplug_event event = args.second;
 
 	DEBUG_LOG("HandleHotplug %p %i", dev, event);
 
-	Handle<Value> v8dev = Device::get(dev);
+	Local<Value> v8dev = Device::get(dev);
 	libusb_unref_device(dev);
 
-	Handle<String> eventName;
+	Local<String> eventName;
 
 	if (LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED == event) {
 		DEBUG_LOG("Device arrived");
-		eventName = NanNew("attach");
+		eventName = Nan::New("attach").ToLocalChecked();
 
 	} else if (LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT == event) {
 		DEBUG_LOG("Device left");
-		eventName = NanNew("detach");
+		eventName = Nan::New("detach").ToLocalChecked();
 
 	} else {
 		DEBUG_LOG("Unhandled hotplug event %d\n", event);
 		return;
 	}
 
-	Handle<Value> argv[] = {eventName, v8dev};
-	NanMakeCallback(NanNew(hotplugThis), "emit", 2, argv);
+	Local<Value> argv[] = {eventName, v8dev};
+	Nan::MakeCallback(Nan::New(hotplugThis), "emit", 2, argv);
 }
 
 bool hotplugEnabled = 0;
@@ -162,10 +157,8 @@ int LIBUSB_CALL hotplug_callback(libusb_context *ctx, libusb_device *dev,
 }
 
 NAN_METHOD(EnableHotplugEvents) {
-	NanScope();
-
 	if (!hotplugEnabled) {
-		NanAssignPersistent(hotplugThis, args.This());
+		hotplugThis.Reset(info.This());
 		CHECK_USB(libusb_hotplug_register_callback(usb_context,
 			(libusb_hotplug_event)(LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT),
 			(libusb_hotplug_flag)0, LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY,
@@ -173,17 +166,14 @@ NAN_METHOD(EnableHotplugEvents) {
 		hotplugQueue.ref();
 		hotplugEnabled = true;
 	}
-	NanReturnValue(NanUndefined());
 }
 
 NAN_METHOD(DisableHotplugEvents) {
-	NanScope();
 	if (hotplugEnabled) {
 		libusb_hotplug_deregister_callback(usb_context, hotplugHandle);
 		hotplugQueue.unref();
 		hotplugEnabled = false;
 	}
-	NanReturnValue(NanUndefined());
 }
 
 void initConstants(Handle<Object> target){
@@ -266,7 +256,7 @@ void initConstants(Handle<Object> target){
 
 Local<Value> libusbException(int errorno) {
 	const char* err = libusb_error_name(errorno);
-	Local<Value> e  = NanError(err);
-	e->ToObject()->Set(NanNew<String>("errno"), NanNew<Integer>(errorno));
+	Local<Value> e  = Nan::Error(err);
+	e->ToObject()->Set(Nan::New<String>("errno").ToLocalChecked(), Nan::New<Integer>(errorno));
 	return e;
 }
diff --git a/src/node_usb.h b/src/node_usb.h
index dca7e36ea..9134dd0ab 100644
--- a/src/node_usb.h
+++ b/src/node_usb.h
@@ -28,7 +28,7 @@ struct Device: public node::ObjectWrap {
 	libusb_device_handle* device_handle;
 
 	static void Init(Handle<Object> exports);
-	static Handle<Value> get(libusb_device* handle);
+	static Local<Value> get(libusb_device* handle);
 
 	inline void ref(){Ref();}
 	inline void unref(){Unref();}
@@ -39,7 +39,7 @@ struct Device: public node::ObjectWrap {
 	static void unpin(libusb_device* device);
 
 	protected:
-		static std::map<libusb_device*, _NanWeakCallbackInfo<Value, libusb_device>*> byPtr;
+		static std::map<libusb_device*, Nan::WeakCallbackInfo<std::pair<Value, libusb_device*>>*> byPtr;
 		Device(libusb_device* d);
 };
 
@@ -64,7 +64,7 @@ struct Transfer: public node::ObjectWrap {
 
 #define CHECK_USB(r) \
 	if (r < LIBUSB_SUCCESS) { \
-		return NanThrowError(libusbException(r)); \
+		return Nan::ThrowError(libusbException(r)); \
 	}
 
 #define CALLBACK_ARG(CALLBACK_ARG_IDX) \
diff --git a/src/transfer.cc b/src/transfer.cc
index e35b94254..b92ffe3ee 100644
--- a/src/transfer.cc
+++ b/src/transfer.cc
@@ -41,7 +41,7 @@ NAN_METHOD(Transfer_constructor) {
 
 	NanAssignPersistent(self->v8callback, callback);
 
-	NanReturnValue(args.This());
+	info.GetReturnValue().Set(args.This());
 }
 
 // Transfer.submit(buffer, callback)
@@ -85,7 +85,7 @@ NAN_METHOD(Transfer_Submit) {
 	);
 
 	CHECK_USB(libusb_submit_transfer(self->transfer));
-	NanReturnValue(args.This());
+	info.GetReturnValue().Set(args.This());
 }
 
 extern "C" void LIBUSB_CALL usbCompletionCb(libusb_transfer *transfer){
@@ -101,7 +101,7 @@ extern "C" void LIBUSB_CALL usbCompletionCb(libusb_transfer *transfer){
 }
 
 void handleCompletion(Transfer* self){
-	NanScope();
+	Nan::HandleScope scope;
 	DEBUG_LOG("HandleCompletion %p", self);
 
 	self->device->unref();
@@ -123,7 +123,7 @@ void handleCompletion(Transfer* self){
 		Handle<Value> argv[] = {error, buffer,
 			NanNew<Uint32>((uint32_t) self->transfer->actual_length)};
 		TryCatch try_catch;
-		NanMakeCallback(NanObjectWrapHandle(self), NanNew(self->v8callback), 3, argv);
+		Nan::MakeCallback(NanObjectWrapHandle(self), NanNew(self->v8callback), 3, argv);
 		if (try_catch.HasCaught()) {
 			FatalException(try_catch);
 		}
@@ -138,10 +138,10 @@ NAN_METHOD(Transfer_Cancel){
 	int r = libusb_cancel_transfer(self->transfer);
 	if (r == LIBUSB_ERROR_NOT_FOUND){
 		// Not useful to throw an error for this case
-		NanReturnValue(NanFalse());
+		info.GetReturnValue().Set(Nan::False());
 	} else {
 		CHECK_USB(r);
-		NanReturnValue(NanTrue());
+		info.GetReturnValue().Set(Nan::True());
 	}
 }