projectdiscovery/katana · error

result is nil

Error message

result is nil

What it means

StandardWriter.Write rejects a nil *Result immediately with 'result is nil' as an argument-invariant guard. It also returns an error for results whose response was filtered out by similarity detection (empty response, no body, no error). The error protects downstream file/screen formatting from nil dereferences.

Source

Thrown at pkg/output/output.go:180

		if err != nil {
			return nil, errkit.Wrap(err, "output: could not create error file")
		}

		writer.errorFile = errorFile
	}
	if options.OutputTemplate != "" {
		writer.outputTemplate, err = fasttemplate.NewTemplate(options.OutputTemplate, "{{", "}}")
		if err != nil {
			return nil, errkit.Wrap(err, "output: could not create output format template")
		}
	}
	return writer, nil
}

// Write writes the result to file and/or screen.
func (w *StandardWriter) Write(result *Result) error {
	if result == nil {
		return errors.New("result is nil")
	}

	// Skip empty responses (e.g., from similarity filtering)
	if result.Response != nil && result.Response.Resp == nil && result.Response.Body == "" && result.Error == "" {
		return errors.New("response filtered by similarity detection")
	}

	if len(w.storeFields) > 0 {
		storeFields(result, w.storeFields)
	}

	if !w.extensionValidator.ValidatePath(result.Request.URL) {
		return errors.New("result does not match extension filter")
	}

	if !w.matchOutput(result) {
		return errors.New("result does not match output")
	}

View on GitHub (pinned to e3e742739c)

Solutions

1. Ensure producers never emit nil results; check for nil before calling writer.Write
2. Treat the error as a programming bug — filter or log it rather than retrying
3. If results are intentionally empty (similarity-filtered), skip them upstream instead of writing

Example fix

// before
writer.Write(result) // result may be nil
// after
if result != nil {
    if err := writer.Write(result); err != nil { log.Error(err) }
}

if result == nil {
    return nil // or skip writing
}
if err := writer.Write(result); err != nil { log.Error(err) }

func writable(r *output.Result) bool { return r != nil && (r.Response == nil || r.Response.Resp != nil || r.Response.Body != "" || r.Error != "") }

if err := writer.Write(result); err != nil {
    if err.Error() == "result is nil" {
        log.Error("pipeline produced nil result — fix producer")
        return nil
    }
    return err
}

When it happens

Trigger: Calling Write(nil) directly or wiring a pipeline (the anonymous caller) that forwards a nil result pointer into the standard writer, e.g. from custom engines or output hooks that forget to check for nil.

Common situations: Custom result producers yielding nil on error paths; pipelines assembling results concurrently where a nil slips through; misuse of the library as a Go dependency rather than CLI usage.

Related errors

• add edge: action cannot be nil
• unknown tag %q
• response filtered by similarity detection
• result does not match extension filter
• result does not match output

AI-assisted analysis of projectdiscovery/katana@e3e742739c (2026-09-03). Data as JSON: /api/errors/a477dbcee2e19c15. Report an issue: GitHub.