diff --git a/package.json b/package.json
index 116f9c0..45348f2 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "beautiful-react-hooks",
-  "version": "5.0.2",
+  "version": "5.0.3",
   "description": "A collection of beautiful (and hopefully useful) React hooks to speed-up your components and hooks development",
   "main": "index.js",
   "module": "esm/index.js",
diff --git a/src/useDebouncedCallback.ts b/src/useDebouncedCallback.ts
index 3a61391..ded628c 100644
--- a/src/useDebouncedCallback.ts
+++ b/src/useDebouncedCallback.ts
@@ -20,18 +20,18 @@ const defaultOptions: DebounceOptions = {
  * If time is not defined, its default value will be 250ms.
  */
 const useDebouncedCallback = <TCallback extends GenericFunction>
-  (fn: TCallback, dependencies?: DependencyList, wait: number = 600, options: DebounceOptions = defaultOptions) => {
+  (fn: TCallback, dependencies: DependencyList = [], wait: number = 600, options: DebounceOptions = defaultOptions) => {
   const debounced = useRef(debounce<TCallback>(fn, wait, options))
 
   useEffect(() => {
     debounced.current = debounce(fn, wait, options)
-  }, [fn, wait, options])
+  }, [fn, wait, options, ...dependencies])
 
   useWillUnmount(() => {
     debounced.current?.cancel()
   })
 
-  return useCallback(debounced.current, dependencies ?? [])
+  return useCallback((...args: Parameters<TCallback>) => debounced.current(...args), [...dependencies])
 }
 
 export default useDebouncedCallback
diff --git a/src/useThrottledCallback.ts b/src/useThrottledCallback.ts
index 8856ca3..177926e 100644
--- a/src/useThrottledCallback.ts
+++ b/src/useThrottledCallback.ts
@@ -19,18 +19,18 @@ const defaultOptions: ThrottleSettings = {
  * If time is not defined, its default value will be 250ms.
  */
 const useThrottledCallback = <TCallback extends GenericFunction>
-  (fn: TCallback, dependencies?: DependencyList, wait: number = 600, options: ThrottleSettings = defaultOptions) => {
+  (fn: TCallback, dependencies: DependencyList = [], wait: number = 600, options: ThrottleSettings = defaultOptions) => {
   const throttled = useRef(throttle<TCallback>(fn, wait, options))
 
   useEffect(() => {
     throttled.current = throttle(fn, wait, options)
-  }, [fn, wait, options])
+  }, [fn, wait, options, ...dependencies])
 
   useWillUnmount(() => {
     throttled.current?.cancel()
   })
 
-  return useCallback(throttled.current, dependencies ?? [])
+  return useCallback((...args: Parameters<TCallback>) => throttled.current(...args), [...dependencies])
 }
 
 export default useThrottledCallback
diff --git a/test/useDebouncedCallback.spec.js b/test/useDebouncedCallback.spec.js
index 4e4eb08..ac1f69d 100644
--- a/test/useDebouncedCallback.spec.js
+++ b/test/useDebouncedCallback.spec.js
@@ -47,4 +47,37 @@ describe('useDebouncedCallback', () => {
     expect(spy.called).to.be.true
     expect(spy.callCount).to.equal(1)
   })
+
+  it('should use the latest callback', async () => {
+    const firstSpy = sinon.spy();
+    const secondSpy = sinon.spy();
+
+    const TestComponent = () => {
+      const [callback, setCallback] = React.useState(() => firstSpy);
+      const debouncedCallback = useDebouncedCallback(callback, [callback], 250);
+
+      React.useEffect(() => {
+        debouncedCallback();
+        debouncedCallback();
+
+        setTimeout(() => {
+          setCallback(() => secondSpy);
+        }, 100);
+
+        setTimeout(() => {
+          debouncedCallback();
+          debouncedCallback();
+        }, 200);
+      }, [debouncedCallback]);
+
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    await promiseDelay(600);
+
+    expect(firstSpy.callCount).to.equal(1); 
+    expect(secondSpy.callCount).to.equal(1); 
+  })
 })
diff --git a/test/useThrottledCallback.spec.js b/test/useThrottledCallback.spec.js
index 4f89d34..09425ff 100644
--- a/test/useThrottledCallback.spec.js
+++ b/test/useThrottledCallback.spec.js
@@ -47,4 +47,34 @@ describe('useThrottledCallback', () => {
     expect(spy.called).to.be.true
     expect(spy.callCount).to.equal(1)
   })
+
+  it('should use the latest callback', async () => {
+    const firstSpy = sinon.spy();
+    const secondSpy = sinon.spy();
+
+    const TestComponent = () => {
+      const [callback, setCallback] = React.useState(() => firstSpy);
+      const throttledCallback = useThrottledCallback(callback, [callback], 250); 
+
+      React.useEffect(() => {
+        throttledCallback();
+        throttledCallback();
+      }, [throttledCallback]);
+
+      React.useEffect(() => {
+        setTimeout(() => {
+          setCallback(() => secondSpy);
+        }, 100);
+      }, []);
+
+      return <div />;
+    };
+
+    render(<TestComponent />);
+
+    await promiseDelay(600);
+
+    expect(firstSpy.callCount).to.equal(1); 
+    expect(secondSpy.callCount).to.equal(1); 
+  })
 })