I have searched up to 4060914647039. Here are all of
the "record" sized values of length 30 or more:

**1. Run of 4k+3 from
113391385603 to 113391386611 (32 consecutive primes, 12 digits each!!!).**

** NOTE that from 113391385507 to 113391386611 is 36
primes with only the 4th one, being 4k+1

**2. Run of 4k+3 from
1742590107899 to 1742590109167 (32 consecutive primes,
13 digits each)**

** NOTE that from 1742590107779 to 1742590109167 is
36 primes with only the 4th one, being 4k+1

**3****. Run of 4k+1 from
3278744415797 to 3278744417029 (33 consecutive primes, 13 digits each)**

**4****. Run of 4k+1 from 3289884073409 to
3289884074597 (30 consecutive primes, 13 digits each)**

These are all example >= 30 consecutive for the
range I tested. There were many example (especially of the p%4==3) that
were beyond the records listed. However, The above are all with length in
the 30's.

My testing method was very simple, but complete. I
simply built a fast SoE which provided enough factors to guarantee it's
output was 100% pure proven prime, and then simply processed each prime
using:

Cnt=0; // start out with our length counter to zero.
b_last_was_pm1=false;

while (p = get_next_prime()) {

if ( (p & 3) == 1) {

// This is a 4k+1 case

if (b_last_was_pm1)

++Cnt; // still on our "run" of p%4==1

else {

// This is the first p%4==1. That means we just "ended" a run of p%4==3.

if (Cnt > 25)

printf ("Found a 4k+3 of len %d ending at %I64u\n", Cnt, p);

Cnt = 1; // we have 1 in our current run

b_last_was_pm1 = true; // Our current run IS p%4==1

}

} else {

// This is a 4k+3 case

if (!b_last_was_pm1)

++Cnt; // still on our "run" of p%4==3

else {

if (Cnt > 23)

printf ("Found a 4k+1 of len %d ending at %I64u\n", Cnt, p);

Cnt = 1; // we have 1 in our current run

b_last_was_pm1 = false; // Our current run is NOT p%4==1

}

}

}

All in all, run time was about **12 GHz hours**
to process the whole range.