diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+# 0.14
+
+- Moved to "iproute" from "network-ip" for inet datatypes
+
 # 0.13
 
 - Removed `PostgreSQL.Binary.Data`. Because it was causing Haddock in the dependant packages to unpredictably redirect to it instead of the original location regardless of whether they were imported from it.
diff --git a/library/PostgreSQL/Binary/Decoding.hs b/library/PostgreSQL/Binary/Decoding.hs
--- a/library/PostgreSQL/Binary/Decoding.hs
+++ b/library/PostgreSQL/Binary/Decoding.hs
@@ -65,13 +65,13 @@
 import qualified Data.Aeson as Aeson
 import qualified Data.ByteString as ByteString
 import qualified Data.ByteString.Lazy as LazyByteString
+import qualified Data.IP as IP
 import qualified Data.Text as Text
 import qualified Data.Text.Encoding as Text
 import qualified Data.Text.Encoding.Error as Text
 import qualified Data.Text.Lazy.Encoding as LazyText
 import qualified Data.UUID as UUID
 import qualified Data.Vector as Vector
-import qualified Network.IP.Addr as IPAddr
 import qualified PostgreSQL.Binary.Inet as Inet
 import qualified PostgreSQL.Binary.Integral as Integral
 import qualified PostgreSQL.Binary.Interval as Interval
@@ -155,35 +155,32 @@
   UUID.fromWords <$> intOfSize 4 <*> intOfSize 4 <*> intOfSize 4 <*> intOfSize 4
 
 {-# INLINE ip4 #-}
-ip4 :: Value IPAddr.IP4
+ip4 :: Value IP.IPv4
 ip4 =
-  IPAddr.ip4FromOctets <$> intOfSize 1 <*> intOfSize 1 <*> intOfSize 1 <*> intOfSize 1
+  IP.toIPv4w <$> intOfSize 4
 
 {-# INLINE ip6 #-}
-ip6 :: Value IPAddr.IP6
+ip6 :: Value IP.IPv6
 ip6 =
-  IPAddr.ip6FromWords <$> intOfSize 2 <*> intOfSize 2 <*> intOfSize 2 <*> intOfSize 2 <*> intOfSize 2 <*> intOfSize 2 <*> intOfSize 2 <*> intOfSize 2
+  IP.toIPv6w <$> ((,,,) <$> intOfSize 4 <*> intOfSize 4 <*> intOfSize 4 <*> intOfSize 4)
 
 {-# INLINEABLE inet #-}
-inet :: Value (IPAddr.NetAddr IPAddr.IP)
+inet :: Value IP.IPRange
 inet = do
   af <- intOfSize 1
   netmask <- intOfSize 1
-  isCidr <- intOfSize 1
-  ipSize <- intOfSize 1
+  isCidr <- intOfSize 1 :: Value Int -- unused
+  ipSize <- intOfSize 1 :: Value Int -- unused
   if
     | af == Inet.inetAddressFamily ->
         do
           ip <- ip4
-          return $ inetFromBytes af netmask isCidr ipSize (IPAddr.IPv4 ip)
+          return . IP.IPv4Range $ IP.makeAddrRange ip netmask
     | af == Inet.inet6AddressFamily ->
         do
           ip <- ip6
-          return $ inetFromBytes af netmask isCidr ipSize (IPAddr.IPv6 ip)
+          return . IP.IPv6Range $ IP.makeAddrRange ip netmask
     | otherwise -> BinaryParser.failure ("Unknown address family: " <> fromString (show af))
-  where
-    inetFromBytes :: Word8 -> Word8 -> Word8 -> Int8 -> IPAddr.IP -> IPAddr.NetAddr IPAddr.IP
-    inetFromBytes _ netmask _ _ ip = IPAddr.netAddr ip netmask
 
 {-# INLINEABLE json_ast #-}
 json_ast :: Value Aeson.Value
diff --git a/library/PostgreSQL/Binary/Encoding.hs b/library/PostgreSQL/Binary/Encoding.hs
--- a/library/PostgreSQL/Binary/Encoding.hs
+++ b/library/PostgreSQL/Binary/Encoding.hs
@@ -70,8 +70,8 @@
 import qualified ByteString.StrictBuilder as C
 import qualified Data.Aeson as R
 import qualified Data.ByteString.Lazy as N
+import qualified Data.IP as G
 import qualified Data.Text.Lazy as L
-import qualified Network.IP.Addr as G
 import qualified PostgreSQL.Binary.Encoding.Builders as B
 import PostgreSQL.Binary.Prelude hiding (bool, length)
 
@@ -201,7 +201,7 @@
   B.uuid
 
 {-# INLINE inet #-}
-inet :: G.NetAddr G.IP -> Encoding
+inet :: G.IPRange -> Encoding
 inet =
   B.inet
 
diff --git a/library/PostgreSQL/Binary/Encoding/Builders.hs b/library/PostgreSQL/Binary/Encoding/Builders.hs
--- a/library/PostgreSQL/Binary/Encoding/Builders.hs
+++ b/library/PostgreSQL/Binary/Encoding/Builders.hs
@@ -5,6 +5,7 @@
 import qualified Data.ByteString.Builder as M
 import qualified Data.ByteString.Lazy as N
 import qualified Data.HashMap.Strict as F
+import qualified Data.IP as G
 import qualified Data.Map.Strict as Q
 import qualified Data.Scientific as D
 import qualified Data.Text.Encoding as J
@@ -12,7 +13,6 @@
 import qualified Data.Text.Lazy.Encoding as K
 import qualified Data.UUID as E
 import qualified Data.Vector as A
-import qualified Network.IP.Addr as G
 import qualified PostgreSQL.Binary.BuilderPrim as I
 import qualified PostgreSQL.Binary.Inet as H
 import qualified PostgreSQL.Binary.Interval as P
@@ -160,36 +160,42 @@
     (w1, w2, w3, w4) -> int4_word32 w1 <> int4_word32 w2 <> int4_word32 w3 <> int4_word32 w4
 
 {-# INLINEABLE ip4 #-}
-ip4 :: G.IP4 -> Builder
-ip4 x =
-  case G.ip4ToOctets x of
-    (w1, w2, w3, w4) -> word8 w1 <> word8 w2 <> word8 w3 <> word8 w4
+ip4 :: G.IPv4 -> Builder
+ip4 =
+  int4_word32 . G.fromIPv4w
 
 {-# INLINEABLE ip6 #-}
-ip6 :: G.IP6 -> Builder
+ip6 :: G.IPv6 -> Builder
 ip6 x =
-  case G.ip6ToWords x of
-    (w1, w2, w3, w4, w5, w6, w7, w8) ->
-      int2_word16 w1
-        <> int2_word16 w2
-        <> int2_word16 w3
-        <> int2_word16 w4
-        <> int2_word16 w5
-        <> int2_word16 w6
-        <> int2_word16 w7
-        <> int2_word16 w8
+  case G.fromIPv6w x of
+    (w1, w2, w3, w4) -> int4_word32 w1 <> int4_word32 w2 <> int4_word32 w3 <> int4_word32 w4
 
-{-# INLINEABLE inet #-}
-inet :: G.NetAddr G.IP -> Builder
-inet i =
-  case G.netHost i of
-    G.IPv4 x -> inetAddressFamily <> netLength <> isCidr <> ip4Size <> ip4 x
-    G.IPv6 x -> inet6AddressFamily <> netLength <> isCidr <> ip6Size <> ip6 x
+{-# INLINEABLE ip4range #-}
+ip4range :: G.AddrRange G.IPv4 -> Builder
+ip4range x =
+  case G.addrRangePair x of
+    (addr, mlen) -> inetAddressFamily <> netLength mlen <> isCidr <> ip4Size <> ip4 addr
   where
     netLength =
-      word8 (G.netLength i)
+      word8 . fromIntegral
     isCidr =
       false1
+
+{-# INLINEABLE ip6range #-}
+ip6range :: G.AddrRange G.IPv6 -> Builder
+ip6range x =
+  case G.addrRangePair x of
+    (addr, mlen) -> inet6AddressFamily <> netLength mlen <> isCidr <> ip6Size <> ip6 addr
+  where
+    netLength =
+      word8 . fromIntegral
+    isCidr =
+      false1
+
+{-# INLINEABLE inet #-}
+inet :: G.IPRange -> Builder
+inet (G.IPv4Range x) = ip4range x
+inet (G.IPv6Range x) = ip6range x
 
 {-# NOINLINE inetAddressFamily #-}
 inetAddressFamily :: Builder
diff --git a/postgresql-binary.cabal b/postgresql-binary.cabal
--- a/postgresql-binary.cabal
+++ b/postgresql-binary.cabal
@@ -1,6 +1,6 @@
 cabal-version:      3.0
 name:               postgresql-binary
-version:            0.13.1.3
+version:            0.14
 synopsis:           Encoders and decoders for the PostgreSQL's binary format
 description:
   An API for dealing with PostgreSQL's binary data format.
@@ -90,7 +90,7 @@
     , bytestring >=0.10.4 && <0.13
     , bytestring-strict-builder >=0.4.5.4 && <0.5
     , containers >=0.5 && <0.8
-    , network-ip >=0.3 && <0.4
+    , iproute >=1.7 && <2
     , scientific >=0.3 && <0.4
     , text >=1.2 && <3
     , time >=1.9 && <2
@@ -118,7 +118,7 @@
 
   build-depends:
     , aeson >=2 && <3
-    , network-ip >=0.2 && <1
+    , iproute >=1.4 && <2
     , postgresql-binary
     , postgresql-libpq >=0.9 && <0.11
     , QuickCheck >=2.10 && <3
diff --git a/tasty/Main.hs b/tasty/Main.hs
--- a/tasty/Main.hs
+++ b/tasty/Main.hs
@@ -136,6 +136,8 @@
             primitiveRoundtrip "bytea_lazy" Gens.auto PTI.bytea A.bytea_lazy B.bytea_lazy,
             primitiveRoundtrip "uuid" Gens.uuid PTI.uuid A.uuid B.uuid,
             primitiveRoundtrip "inet" Gens.inet PTI.inet A.inet B.inet,
+            select "SELECT '127.0.0.1' :: inet" (const B.inet) (read "127.0.0.1"),
+            select "SELECT '::1' :: inet" (const B.inet) (read "::1"),
             primitiveRoundtrip "int2_int16" Gens.auto PTI.int2 A.int2_int16 B.int,
             primitiveRoundtrip "int2_word16" Gens.auto PTI.int2 A.int2_word16 B.int,
             primitiveRoundtrip "int4_int32" Gens.auto PTI.int4 A.int4_int32 B.int,
diff --git a/tasty/Main/Gens.hs b/tasty/Main/Gens.hs
--- a/tasty/Main/Gens.hs
+++ b/tasty/Main/Gens.hs
@@ -4,12 +4,12 @@
 import qualified Data.Aeson.Key as AesonKey
 import qualified Data.Aeson.KeyMap as AesonKeyMap
 import qualified Data.HashMap.Strict as HashMap
+import qualified Data.IP as IP
 import qualified Data.Scientific as Scientific
 import qualified Data.Text as Text
 import qualified Data.UUID as UUID
 import qualified Data.Vector as Vector
 import Main.Prelude hiding (choose, isLeft, isRight)
-import qualified Network.IP.Addr as IPAddr
 import Test.QuickCheck hiding (vector)
 
 maybeOf :: Gen a -> Gen (Maybe a)
@@ -126,26 +126,24 @@
 uuid =
   UUID.fromWords <$> arbitrary <*> arbitrary <*> arbitrary <*> arbitrary
 
-inet :: Gen (IPAddr.NetAddr IPAddr.IP)
+inet :: Gen IP.IPRange
 inet = do
   ipv6 <- choose (True, False)
   if ipv6
     then
-      IPAddr.netAddr
-        <$> ( IPAddr.IPv6
-                <$> ( IPAddr.ip6FromWords
-                        <$> arbitrary
-                        <*> arbitrary
-                        <*> arbitrary
-                        <*> arbitrary
-                        <*> arbitrary
-                        <*> arbitrary
-                        <*> arbitrary
-                        <*> arbitrary
+      IP.IPv6Range
+        <$> ( IP.makeAddrRange
+                <$> ( IP.toIPv6w
+                        <$> ( (,,,)
+                                <$> arbitrary
+                                <*> arbitrary
+                                <*> arbitrary
+                                <*> arbitrary
+                            )
                     )
+                <*> choose (0, 128)
             )
-        <*> choose (0, 128)
-    else IPAddr.netAddr <$> (IPAddr.IPv4 <$> (IPAddr.ip4FromOctets <$> arbitrary <*> arbitrary <*> arbitrary <*> arbitrary)) <*> choose (0, 32)
+    else IP.IPv4Range <$> (IP.makeAddrRange <$> (IP.toIPv4w <$> arbitrary) <*> choose (0, 32))
 
 array3 :: Gen a -> Gen [[[a]]]
 array3 gen =