projectdiscovery/subfinder · error

could not init multi rate limiter for

Error message

could not init multi rate limiter for %s: %s

What it means

Runtime error emitted on the results channel by Agent.EnumerateSubdomainsWithCtx when buildMultiRateLimiter fails for a domain — typically because the configured rate limit string or custom per-source limiter cannot be parsed/initialized. The domain and the underlying error are interpolated into the message, and enumeration for that domain is aborted (the goroutine returns after pushing a subscraping.Error result).

Solutions

1. Inspect the trailing %s in the message — it carries the underlying limiter initialization error (e.g. an unparseable rate-limit spec)
2. Fix or remove the -rl/rls rate-limit configuration so a valid MultiLimiter can be built
3. Since the error arrives as a Result of Type Error on the channel, drain the channel and surface the error to the user instead of treating the run as complete

When it happens

Trigger: Thrown at pkg/passive/passive.go:68 when the library encounters an invalid state.

Common situations: See trigger scenarios.

AI-assisted analysis of projectdiscovery/subfinder@7a0b91f0fa (2026-09-06). Data as JSON: /api/errors/f08dbf07fa87cec4. Report an issue: GitHub.

Appendix: source

Thrown at pkg/passive/passive.go:68

	return a.EnumerateSubdomainsWithCtx(context.Background(), domain, proxy, rateLimit, timeout, maxEnumTime, options...)
}

// EnumerateSubdomainsWithCtx enumerates all the subdomains for a given domain
func (a *Agent) EnumerateSubdomainsWithCtx(ctx context.Context, domain string, proxy string, rateLimit int, timeout int, maxEnumTime time.Duration, options ...EnumerateOption) chan subscraping.Result {
	results := make(chan subscraping.Result)

	go func() {
		defer close(results)

		var enumerateOptions EnumerationOptions
		for _, enumerateOption := range options {
			enumerateOption(&enumerateOptions)
		}

		multiRateLimiter, err := a.buildMultiRateLimiter(ctx, rateLimit, enumerateOptions.customRateLimiter)
		if err != nil {
			results <- subscraping.Result{
				Type: subscraping.Error, Error: fmt.Errorf("could not init multi rate limiter for %s: %s", domain, err),
			}
			return
		}
		session, err := subscraping.NewSession(domain, proxy, multiRateLimiter, timeout)
		if err != nil {
			results <- subscraping.Result{
				Type: subscraping.Error, Error: fmt.Errorf("could not init passive session for %s: %s", domain, err),
			}
			return
		}
		defer session.Close()
		session.MaxResults = enumerateOptions.maxResults
		session.MaxResponseBodySize = enumerateOptions.maxResponseBodySize

		ctx, cancel := context.WithTimeout(ctx, maxEnumTime)

		wg := &sync.WaitGroup{}
		// Run each source in parallel on the target domain

View on GitHub (pinned to 7a0b91f0fa)