diff --git a/values4k/src/main/kotlin/dev/forkhandles/values/ValueFactory.kt b/values4k/src/main/kotlin/dev/forkhandles/values/ValueFactory.kt
index 10f0874..e93d07b 100644
--- a/values4k/src/main/kotlin/dev/forkhandles/values/ValueFactory.kt
+++ b/values4k/src/main/kotlin/dev/forkhandles/values/ValueFactory.kt
@@ -7,7 +7,9 @@ abstract class ValueFactory<DOMAIN : Value<PRIMITIVE>, PRIMITIVE : Any>(
     internal val coerceFn: (PRIMITIVE) -> DOMAIN,
     private val validation: Validation<PRIMITIVE>? = null,
     internal val parseFn: (String) -> PRIMITIVE,
-    internal val showFn: (PRIMITIVE) -> String = { it.toString() }
+    internal val showFn: (PRIMITIVE) -> String = { it.toString() },
+    internal val onInvalid: ValueFactory<DOMAIN, PRIMITIVE>.(PRIMITIVE, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    internal val onParseFailure: ValueFactory<DOMAIN, PRIMITIVE>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) }
 ) {
     internal fun validate(value: PRIMITIVE): DOMAIN {
         validation?.check(value)
@@ -17,21 +19,21 @@ abstract class ValueFactory<DOMAIN : Value<PRIMITIVE>, PRIMITIVE : Any>(
     @Deprecated("Use of()", ReplaceWith("of(value)"))
     operator fun invoke(value: PRIMITIVE): Any = error("invoke() factory method is not to be used for building microtypes -  use of() instead!")
 
-    open fun parse(value: String) = attempt { validate(parseFn(value)) }
+    open fun parse(value: String): DOMAIN {
+        val parsed = attempt({ onParseFailure(value, it) }) { parseFn(value) }
+        return attempt({ onInvalid(parsed, it) }) { validate(parsed) }
+    }
 
     fun show(value: DOMAIN) = showFn(unwrap(value))
 
-    open fun of(value: PRIMITIVE) = attempt { validate(value) }
+    open fun of(value: PRIMITIVE) = attempt({ onInvalid(value, it) }) { validate(value) }
 
     fun unwrap(value: DOMAIN) = value.value
 
-    private fun <T> attempt(value: () -> T) = try {
+    private fun <T> attempt(onError: (Exception) -> Nothing, value: () -> T) = try {
         value()
     } catch (e: Exception) {
-        throw IllegalArgumentException(
-            this::class.java.name.substringBeforeLast('$') +
-                ": " + e::class.java.name + " " + e.localizedMessage
-        )
+        onError(e)
     }
 }
 
@@ -46,3 +48,10 @@ fun <DOMAIN : Value<PRIMITIVE>, PRIMITIVE : Any> ValueFactory<DOMAIN, PRIMITIVE>
 
 fun <DOMAIN : Value<PRIMITIVE>, PRIMITIVE : Any> ValueFactory<DOMAIN, PRIMITIVE>.showList(values: List<DOMAIN>) =
     values.map(::show)
+
+internal fun ValueFactory<*, *>.defaultOnInvalid(e: Exception): Nothing {
+    throw IllegalArgumentException(
+        this::class.java.name.substringBeforeLast('$') +
+            ": " + e::class.java.name + " " + e.localizedMessage
+    )
+}
diff --git a/values4k/src/main/kotlin/dev/forkhandles/values/factories.kt b/values4k/src/main/kotlin/dev/forkhandles/values/factories.kt
index d1167c4..3e9c0f5 100644
--- a/values4k/src/main/kotlin/dev/forkhandles/values/factories.kt
+++ b/values4k/src/main/kotlin/dev/forkhandles/values/factories.kt
@@ -35,25 +35,33 @@ private val base36Alphabet get() = "^[0-9A-Z=]+$".toRegex()
 
 open class StringValueFactory<DOMAIN : Value<String>>(
     fn: (String) -> DOMAIN, validation: Validation<String>? = null,
-    showFn: (String) -> String = { it }
-) : ValueFactory<DOMAIN, String>(fn, validation, { it }, showFn)
+    showFn: (String) -> String = { it },
+    onInvalid: ValueFactory<DOMAIN, String>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, String>.(String, Exception) -> Nothing = onInvalid,
+) : ValueFactory<DOMAIN, String>(fn, validation, { it }, showFn, onInvalid, onParseFailure)
 
 open class NonEmptyStringValueFactory<DOMAIN : Value<String>>(
     fn: (String) -> DOMAIN,
-    showFn: (String) -> String = { it }
-) : ValueFactory<DOMAIN, String>(fn, 1.minLength, { it }, showFn)
+    showFn: (String) -> String = { it },
+    onInvalid: ValueFactory<DOMAIN, String>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, String>.(String, Exception) -> Nothing = onInvalid,
+) : ValueFactory<DOMAIN, String>(fn, 1.minLength, { it }, showFn, onInvalid, onParseFailure)
 
 open class NonBlankStringValueFactory<DOMAIN : Value<String>>(
     fn: (String) -> DOMAIN,
-    showFn: (String) -> String = { it }
-) : ValueFactory<DOMAIN, String>(fn, 1.minLength.let { v -> { v(it.trim()) } }, { it }, showFn)
+    showFn: (String) -> String = { it },
+    onInvalid: ValueFactory<DOMAIN, String>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, String>.(String, Exception) -> Nothing = onInvalid,
+) : ValueFactory<DOMAIN, String>(fn, 1.minLength.let { v -> { v(it.trim()) } }, { it }, showFn, onInvalid, onParseFailure)
 
 open class Base64StringValueFactory<DOMAIN : Value<String>>(
     fn: (String) -> DOMAIN,
     validation: Validation<String> = { true },
     parseFn: (String) -> String = { it },
     showFn: (String) -> String = { it },
-) : ValueFactory<DOMAIN, String>(fn, rfcBase64Alphabet::matches.and(validation), parseFn, showFn) {
+    onInvalid: ValueFactory<DOMAIN, String>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, String>.(String, Exception) -> Nothing = onInvalid,
+) : ValueFactory<DOMAIN, String>(fn, rfcBase64Alphabet::matches.and(validation), parseFn, showFn, onInvalid, onParseFailure) {
     private val encoder = Base64.getEncoder()
     fun encode(value: ByteArray) = encoder.encodeToString(value).let(coerceFn)
 }
@@ -63,21 +71,27 @@ open class Base36StringValueFactory<DOMAIN : Value<String>>(
     validation: Validation<String> = { true },
     parseFn: (String) -> String = { it },
     showFn: (String) -> String = { it },
-) : ValueFactory<DOMAIN, String>(fn, base36Alphabet::matches.and(validation), parseFn, showFn)
+    onInvalid: ValueFactory<DOMAIN, String>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, String>.(String, Exception) -> Nothing = onInvalid,
+) : ValueFactory<DOMAIN, String>(fn, base36Alphabet::matches.and(validation), parseFn, showFn, onInvalid, onParseFailure)
 
 open class Base32StringValueFactory<DOMAIN : Value<String>>(
     fn: (String) -> DOMAIN,
     validation: Validation<String> = { true },
     parseFn: (String) -> String = { it },
     showFn: (String) -> String = { it },
-) : ValueFactory<DOMAIN, String>(fn, rfcBase32Alphabet::matches.and(validation), parseFn, showFn)
+    onInvalid: ValueFactory<DOMAIN, String>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, String>.(String, Exception) -> Nothing = onInvalid,
+) : ValueFactory<DOMAIN, String>(fn, rfcBase32Alphabet::matches.and(validation), parseFn, showFn, onInvalid, onParseFailure)
 
 open class Base16StringValueFactory<DOMAIN : Value<String>>(
     fn: (String) -> DOMAIN,
     validation: Validation<String> = { true },
     parseFn: (String) -> String = { it },
     showFn: (String) -> String = { it },
-) : ValueFactory<DOMAIN, String>(fn, rfcBase16Alphabet::matches.and(validation), parseFn, showFn) {
+    onInvalid: ValueFactory<DOMAIN, String>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, String>.(String, Exception) -> Nothing = onInvalid,
+) : ValueFactory<DOMAIN, String>(fn, rfcBase16Alphabet::matches.and(validation), parseFn, showFn, onInvalid, onParseFailure) {
     // Source: https://stackoverflow.com/a/9855338/1253613
     private val base16Chars = "0123456789ABCDEF".toCharArray()
     fun encode(bytes: ByteArray): DOMAIN {
@@ -92,106 +106,150 @@ open class Base16StringValueFactory<DOMAIN : Value<String>>(
 }
 
 open class CharValueFactory<DOMAIN : Value<Char>>(
-    fn: (Char) -> DOMAIN, validation: Validation<Char>? = null
-) : ValueFactory<DOMAIN, Char>(fn, validation, String::first)
+    fn: (Char) -> DOMAIN, validation: Validation<Char>? = null,
+    onInvalid: ValueFactory<DOMAIN, Char>.(Char, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, Char>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, Char>(fn, validation, String::first, onInvalid = onInvalid, onParseFailure = onParseFailure)
 
 open class IntValueFactory<DOMAIN : Value<Int>>(
-    fn: (Int) -> DOMAIN, validation: Validation<Int>? = null
-) : ValueFactory<DOMAIN, Int>(fn, validation, String::toInt)
+    fn: (Int) -> DOMAIN, validation: Validation<Int>? = null,
+    onInvalid: ValueFactory<DOMAIN, Int>.(Int, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, Int>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, Int>(fn, validation, String::toInt, onInvalid = onInvalid, onParseFailure = onParseFailure)
 
 open class LongValueFactory<DOMAIN : Value<Long>>(
-    fn: (Long) -> DOMAIN, validation: Validation<Long>? = null
-) : ValueFactory<DOMAIN, Long>(fn, validation, String::toLong)
+    fn: (Long) -> DOMAIN, validation: Validation<Long>? = null,
+    onInvalid: ValueFactory<DOMAIN, Long>.(Long, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, Long>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, Long>(fn, validation, String::toLong, onInvalid = onInvalid, onParseFailure = onParseFailure)
 
 open class DoubleValueFactory<DOMAIN : Value<Double>>(
-    fn: (Double) -> DOMAIN, validation: Validation<Double>? = null
-) : ValueFactory<DOMAIN, Double>(fn, validation, String::toDouble)
+    fn: (Double) -> DOMAIN, validation: Validation<Double>? = null,
+    onInvalid: ValueFactory<DOMAIN, Double>.(Double, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, Double>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, Double>(fn, validation, String::toDouble, onInvalid = onInvalid, onParseFailure = onParseFailure)
 
 open class FloatValueFactory<DOMAIN : Value<Float>>(
-    fn: (Float) -> DOMAIN, validation: Validation<Float>? = null
-) : ValueFactory<DOMAIN, Float>(fn, validation, String::toFloat)
+    fn: (Float) -> DOMAIN, validation: Validation<Float>? = null,
+    onInvalid: ValueFactory<DOMAIN, Float>.(Float, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, Float>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, Float>(fn, validation, String::toFloat, onInvalid = onInvalid, onParseFailure = onParseFailure)
 
 open class BooleanValueFactory<DOMAIN : Value<Boolean>>(
-    fn: (Boolean) -> DOMAIN, validation: Validation<Boolean>? = null
-) : ValueFactory<DOMAIN, Boolean>(fn, validation, String::toBoolean)
+    fn: (Boolean) -> DOMAIN, validation: Validation<Boolean>? = null,
+    onInvalid: ValueFactory<DOMAIN, Boolean>.(Boolean, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, Boolean>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, Boolean>(fn, validation, String::toBoolean, onInvalid = onInvalid, onParseFailure = onParseFailure)
 
 open class BigIntegerValueFactory<DOMAIN : Value<BigInteger>>(
-    fn: (BigInteger) -> DOMAIN, validation: Validation<BigInteger>? = null
-) : ValueFactory<DOMAIN, BigInteger>(fn, validation, String::toBigInteger)
+    fn: (BigInteger) -> DOMAIN, validation: Validation<BigInteger>? = null,
+    onInvalid: ValueFactory<DOMAIN, BigInteger>.(BigInteger, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, BigInteger>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, BigInteger>(fn, validation, String::toBigInteger, onInvalid = onInvalid, onParseFailure = onParseFailure)
 
 open class BigDecimalValueFactory<DOMAIN : Value<BigDecimal>>(
-    fn: (BigDecimal) -> DOMAIN, validation: Validation<BigDecimal>? = null
-) : ValueFactory<DOMAIN, BigDecimal>(fn, validation, String::toBigDecimal)
+    fn: (BigDecimal) -> DOMAIN, validation: Validation<BigDecimal>? = null,
+    onInvalid: ValueFactory<DOMAIN, BigDecimal>.(BigDecimal, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, BigDecimal>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, BigDecimal>(fn, validation, String::toBigDecimal, onInvalid = onInvalid, onParseFailure = onParseFailure)
 
 open class UUIDValueFactory<DOMAIN : Value<UUID>>(
-    fn: (UUID) -> DOMAIN, validation: Validation<UUID>? = null
-) : ValueFactory<DOMAIN, UUID>(fn, validation, UUID::fromString)
+    fn: (UUID) -> DOMAIN, validation: Validation<UUID>? = null,
+    onInvalid: ValueFactory<DOMAIN, UUID>.(UUID, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, UUID>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, UUID>(fn, validation, UUID::fromString, onInvalid = onInvalid, onParseFailure = onParseFailure)
 
 open class URLValueFactory<DOMAIN : Value<URL>>(
-    fn: (URL) -> DOMAIN, validation: Validation<URL>? = null
-) : ValueFactory<DOMAIN, URL>(fn, validation, ::URL)
+    fn: (URL) -> DOMAIN, validation: Validation<URL>? = null,
+    onInvalid: ValueFactory<DOMAIN, URL>.(URL, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, URL>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, URL>(fn, validation, ::URL, onInvalid = onInvalid, onParseFailure = onParseFailure)
 
 open class DurationValueFactory<DOMAIN : Value<Duration>>(
-    fn: (Duration) -> DOMAIN, validation: Validation<Duration>? = null
-) : ValueFactory<DOMAIN, Duration>(fn, validation, { Duration.parse(it) })
+    fn: (Duration) -> DOMAIN, validation: Validation<Duration>? = null,
+    onInvalid: ValueFactory<DOMAIN, Duration>.(Duration, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, Duration>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, Duration>(fn, validation, { Duration.parse(it) }, onInvalid = onInvalid, onParseFailure = onParseFailure)
 
 open class InstantValueFactory<DOMAIN : Value<Instant>>(
     fn: (Instant) -> DOMAIN, validation: Validation<Instant>? = null,
-    fmt: DateTimeFormatter = ISO_INSTANT
-) : ValueFactory<DOMAIN, Instant>(fn, validation, { fmt.parse(it, Instant::from) }, fmt::format)
+    fmt: DateTimeFormatter = ISO_INSTANT,
+    onInvalid: ValueFactory<DOMAIN, Instant>.(Instant, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, Instant>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, Instant>(fn, validation, { fmt.parse(it, Instant::from) }, fmt::format, onInvalid, onParseFailure)
 
 open class LocalDateValueFactory<DOMAIN : Value<LocalDate>>(
     fn: (LocalDate) -> DOMAIN, validation: Validation<LocalDate>? = null,
-    fmt: DateTimeFormatter = ISO_LOCAL_DATE
-) : ValueFactory<DOMAIN, LocalDate>(fn, validation, { LocalDate.parse(it, fmt) }, fmt::format)
+    fmt: DateTimeFormatter = ISO_LOCAL_DATE,
+    onInvalid: ValueFactory<DOMAIN, LocalDate>.(LocalDate, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, LocalDate>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, LocalDate>(fn, validation, { LocalDate.parse(it, fmt) }, fmt::format, onInvalid, onParseFailure)
 
 open class LocalTimeValueFactory<DOMAIN : Value<LocalTime>>(
     fn: (LocalTime) -> DOMAIN,
     validation: Validation<LocalTime>? = null,
-    fmt: DateTimeFormatter = ISO_LOCAL_TIME
-) : ValueFactory<DOMAIN, LocalTime>(fn, validation, { LocalTime.parse(it, fmt) }, fmt::format)
+    fmt: DateTimeFormatter = ISO_LOCAL_TIME,
+    onInvalid: ValueFactory<DOMAIN, LocalTime>.(LocalTime, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, LocalTime>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, LocalTime>(fn, validation, { LocalTime.parse(it, fmt) }, fmt::format, onInvalid, onParseFailure)
 
 open class LocalDateTimeValueFactory<DOMAIN : Value<LocalDateTime>>(
     fn: (LocalDateTime) -> DOMAIN,
     validation: Validation<LocalDateTime>? = null,
-    fmt: DateTimeFormatter = ISO_LOCAL_DATE_TIME
-) : ValueFactory<DOMAIN, LocalDateTime>(fn, validation, { LocalDateTime.parse(it, fmt) }, fmt::format)
+    fmt: DateTimeFormatter = ISO_LOCAL_DATE_TIME,
+    onInvalid: ValueFactory<DOMAIN, LocalDateTime>.(LocalDateTime, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, LocalDateTime>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, LocalDateTime>(fn, validation, { LocalDateTime.parse(it, fmt) }, fmt::format, onInvalid, onParseFailure)
 
 open class OffsetDateTimeValueFactory<DOMAIN : Value<OffsetDateTime>>(
     fn: (OffsetDateTime) -> DOMAIN,
     validation: Validation<OffsetDateTime>? = null,
-    fmt: DateTimeFormatter = ISO_OFFSET_DATE_TIME
-) : ValueFactory<DOMAIN, OffsetDateTime>(fn, validation, { OffsetDateTime.parse(it, fmt) }, fmt::format)
+    fmt: DateTimeFormatter = ISO_OFFSET_DATE_TIME,
+    onInvalid: ValueFactory<DOMAIN, OffsetDateTime>.(OffsetDateTime, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, OffsetDateTime>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, OffsetDateTime>(fn, validation, { OffsetDateTime.parse(it, fmt) }, fmt::format, onInvalid, onParseFailure)
 
 open class OffsetTimeValueFactory<DOMAIN : Value<OffsetTime>>(
     fn: (OffsetTime) -> DOMAIN,
     validation: Validation<OffsetTime>? = null,
-    fmt: DateTimeFormatter = ISO_OFFSET_TIME
-) : ValueFactory<DOMAIN, OffsetTime>(fn, validation, { OffsetTime.parse(it, fmt) }, fmt::format)
+    fmt: DateTimeFormatter = ISO_OFFSET_TIME,
+    onInvalid: ValueFactory<DOMAIN, OffsetTime>.(OffsetTime, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, OffsetTime>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, OffsetTime>(fn, validation, { OffsetTime.parse(it, fmt) }, fmt::format, onInvalid, onParseFailure)
 
 open class PeriodValueFactory<DOMAIN : Value<Period>>(
     fn: (Period) -> DOMAIN,
-    validation: Validation<Period>? = null
-) : ValueFactory<DOMAIN, Period>(fn, validation, { Period.parse(it) })
+    validation: Validation<Period>? = null,
+    onInvalid: ValueFactory<DOMAIN, Period>.(Period, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, Period>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, Period>(fn, validation, { Period.parse(it) }, Period::toString, onInvalid, onParseFailure)
 
 open class YearMonthValueFactory<DOMAIN : Value<YearMonth>>(
     fn: (YearMonth) -> DOMAIN,
     validation: Validation<YearMonth>? = null,
-    fmt: DateTimeFormatter = ofPattern("yyyy-MM")
-) : ValueFactory<DOMAIN, YearMonth>(fn, validation, { YearMonth.parse(it, fmt) }, fmt::format)
+    fmt: DateTimeFormatter = ofPattern("yyyy-MM"),
+    onInvalid: ValueFactory<DOMAIN, YearMonth>.(YearMonth, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, YearMonth>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, YearMonth>(fn, validation, { YearMonth.parse(it, fmt) }, fmt::format, onInvalid, onParseFailure)
 
 open class YearValueFactory<DOMAIN : Value<Year>>(
     fn: (Year) -> DOMAIN,
     validation: Validation<Year>? = null,
-    fmt: DateTimeFormatter = ofPattern("yyyy")
-) : ValueFactory<DOMAIN, Year>(fn, validation, { Year.parse(it, fmt) }, fmt::format)
+    fmt: DateTimeFormatter = ofPattern("yyyy"),
+    onInvalid: ValueFactory<DOMAIN, Year>.(Year, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, Year>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, Year>(fn, validation, { Year.parse(it, fmt) }, fmt::format, onInvalid, onParseFailure)
 
 open class ZonedDateTimeValueFactory<DOMAIN : Value<ZonedDateTime>>(
     fn: (ZonedDateTime) -> DOMAIN,
     validation: Validation<ZonedDateTime>? = null,
-    fmt: DateTimeFormatter = ISO_ZONED_DATE_TIME
-) : ValueFactory<DOMAIN, ZonedDateTime>(fn, validation, { ZonedDateTime.parse(it, fmt) }, fmt::format)
+    fmt: DateTimeFormatter = ISO_ZONED_DATE_TIME,
+    onInvalid: ValueFactory<DOMAIN, ZonedDateTime>.(ZonedDateTime, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, ZonedDateTime>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, ZonedDateTime>(fn, validation, { ZonedDateTime.parse(it, fmt) }, fmt::format, onInvalid, onParseFailure)
 
 open class FileValueFactory<DOMAIN : Value<File>>(
-    fn: (File) -> DOMAIN, validation: Validation<File>? = null
-) : ValueFactory<DOMAIN, File>(fn, validation, { File(it) })
+    fn: (File) -> DOMAIN, validation: Validation<File>? = null,
+    onInvalid: ValueFactory<DOMAIN, File>.(File, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+    onParseFailure: ValueFactory<DOMAIN, File>.(String, Exception) -> Nothing = { _, e -> defaultOnInvalid(e) },
+) : ValueFactory<DOMAIN, File>(fn, validation, { File(it) }, onInvalid = onInvalid, onParseFailure = onParseFailure)
diff --git a/values4k/src/test/kotlin/dev/forkhandles/values/ValueFactoryTest.kt b/values4k/src/test/kotlin/dev/forkhandles/values/ValueFactoryTest.kt
index b15df1e..f270997 100644
--- a/values4k/src/test/kotlin/dev/forkhandles/values/ValueFactoryTest.kt
+++ b/values4k/src/test/kotlin/dev/forkhandles/values/ValueFactoryTest.kt
@@ -7,6 +7,7 @@ import com.natpryce.hamkrest.throws
 import dev.forkhandles.result4k.Failure
 import dev.forkhandles.result4k.Success
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
 
 class ValueFactoryTest {
 
@@ -114,4 +115,20 @@ class ValueFactoryTest {
         assertThat(MyIntValue.showList(MyIntValue.of(123), MyIntValue.of(456)), equalTo(listOf("123", "456")))
     }
 
+    @Test
+    fun customOnInvalid() {
+        val exception = assertThrows<IllegalArgumentException> {
+            MyIntValue.parse("-1")
+        }
+        assertThat(exception.message, equalTo("Value (-1) must be greater than 0"))
+    }
+
+    @Test
+    fun customOnFailedParse() {
+        val exception = assertThrows<IllegalArgumentException> {
+            MyIntValue.parse("cat")
+        }
+        assertThat(exception.message, equalTo("Value (cat) must be an integer"))
+    }
+
 }
diff --git a/values4k/src/test/kotlin/dev/forkhandles/values/ValueTest.kt b/values4k/src/test/kotlin/dev/forkhandles/values/ValueTest.kt
index 6a71bf9..6331eb6 100644
--- a/values4k/src/test/kotlin/dev/forkhandles/values/ValueTest.kt
+++ b/values4k/src/test/kotlin/dev/forkhandles/values/ValueTest.kt
@@ -16,7 +16,10 @@ class MyValue private constructor(value: String) : StringValue(value) {
 }
 
 class MyIntValue private constructor(value: Int) : IntValue(value) {
-    companion object : IntValueFactory<MyIntValue>(::MyIntValue, { it > 0 })
+    companion object : IntValueFactory<MyIntValue>(::MyIntValue, { it > 0 },
+        onInvalid = { value, e -> throw IllegalArgumentException("Value ($value) must be greater than 0", e) },
+        onParseFailure = { value, e -> throw IllegalArgumentException("Value ($value) must be an integer", e) }
+    )
 }
 
 class HiddenValue private constructor(value: String) : StringValue(value, masking = hidden('t')) {